How to make anatomy x-ray and cutaway videos with Claude

A translucent body turns slowly on a dark background. A glowing path traces how a sip of water travels from mouth to kidneys. Or a smartwatch flips over, its sensor dome lights green, and a cutaway shows the photodiodes reading your pulse. Anatomy and cutaway videos explain something hidden by making it visible, and they have become one of the most shared formats made with Claude.

This tutorial covers the method behind them, built mainly on the anatomy skill and the people who published how they use it. The core idea is unusual and worth understanding before you write a single prompt: the best of these videos are not drawings of a thing, they are working models of it.

Two families of the format

The glass body x-ray is the health and fitness version: a stylised translucent figure with one organ system lit at a time, often used to market apps in that niche. The cutaway machine is the explainer version: a recognisable object built from many small parts, with a window cut into the part where the real work happens and a button or a cursor that runs each step.

Both rely on the same three things. A reveal (something opaque becomes see-through, or a shell comes apart). A cause and an effect visible at the same time. And numbers on screen that are real.

What creators published and claimed

Elvar (@elvar_official) published the most detailed method, an article with every prompt for building "a machine you can run" with the free anatomy skill by wheresryan22 (MIT licence), and then turning it into a video. His espresso machine shows a spring pushing water through coffee at 9 bar, with every number driven from one model. He reports that kids' lessons built this way reached over 110,000 views each; those are his figures.

renproton recommends pairing it with an anatomy-reveal skill for real-scale 3D models, motion-blurred reveal films and exploded views. And Deser apps posted about a glass-body anatomy account with 18 million views across 26 posts, saying the videos were one-shot with Opus 5.5 and pitching them as marketing for fitness apps. No method was shared and the numbers are his claims, but it shows the format is recognised.

Step 1: pick a question with a moving part and a number

The best subjects have something that moves and something you can measure. How does a toilet refill? How do bike gears make pedalling easier? How does a smartwatch read your heart rate? How does a kidney filter blood? Each has a mechanism to cut open and a number that changes as it works.

Pick a question you cannot answer yourself. If you already know the answer, you will skip the step that makes these videos good, which is getting the mechanism right.

Step 2: write the model before the drawing

This is the step that separates a convincing cutaway from a pretty diagram. Before anything is drawn, ask Claude to write one small model of the real thing as a pure function: inputs, the physics or biology that matters, and outputs over time. Then drive every number on screen, every gauge, display and label, from that one function. They cannot disagree with each other because they read the same source.

Ask it to flag any number it is not sure of and say where it comes from. Elvar's espresso model prints its own check when it builds (shot time, first drops, yield), which is the kind of self-test worth asking for.

Sketch: a heart-rate sensor model that drives the whole figure

// one pure function of time; everything on screen reads it
function ppg(t, bpm = 72) {
  const beat = (t * bpm / 60) % 1;              // phase in the cycle
  const pulse = Math.exp(-((beat - 0.15) ** 2) / 0.004); // systolic peak
  const blood = 0.6 + 0.4 * pulse;               // blood volume, relative
  const reflected = 1 - 0.35 * blood;            // green light absorbed
  return { beat, blood, reflected, bpm };
}

window.seek = (t) => {
  const m = ppg(t);
  drawArtery(m.blood);            // vessel swells with each beat
  drawLED(t);                     // green flashes
  drawDiode(m.reflected);         // returned light dims on each beat
  drawTrace(t, ppg);              // waveform from the same model
  drawReadout(`${m.bpm} BPM`);  // the number cannot disagree
};

The numbers here are illustrative; for a real video, have Claude source the physiology and label anything it estimates.

Step 3: a window into the part doing the work

Every good cutaway has one window. Not a diagram beside the object, but a cut into it, so the viewer sees the cause and the effect together: the spring and the pressure gauge, the LED and the vessel, the gear teeth and the wheel. Choose that window before styling anything. If you cannot point to the one place the work happens, the video explains two things and lands neither.

End with one sentence under the figure, the big idea. "A spring makes the pressure." "Blood absorbs green light." If you cannot say it in one line, the figure is trying to do too much.

Step 4: make it readable at a glance

The anatomy skill's examples are built to be readable by a seven year old without dumbing down the numbers, and that is a good test for a Short too. A hint for an adult should be graspable in half a second.

• One short line per step, at the top: what is happening and why.
• Small handwritten sound words on the action (a hiss, a click, a thump): cheap, and they make the motion feel physical.
• A speed badge whenever a step runs faster or slower than real time (x4, x1/20), computed from real seconds, so the on-screen clock can still say the true duration.
• Every dial, display and label on a face that nothing else hides.

Step 5: give it a look that is not a technical drawing

Left to defaults, cutaways look like engineering diagrams: thin grey lines, blue highlights, long purple shadows. The look that travels is warmer. Elvar's spec is "a hand-inked children's book, not a technical drawing": dark navy outlines at about 1.2 pixels, flat fills with three tones per colour (top lightest, sides darker), a cream paper background, one bold colour per object, chrome and brass for metal, and short hard-edged warm grey shadows that are "never blue or purple". He notes that every line in that spec is a fix for something the first version got wrong.

For the glass body, the equivalent decisions are a dark background, a body silhouette at low opacity with a soft rim light, one organ system at full saturation at a time, and a single accent colour for whatever is flowing. One system per shot, never the whole body lit at once.

Step 6: check it like a critic, with numbers

The most useful habit in Elvar's method is a numerical check for jumps. Capture a still in the middle of every step and read it for hidden parts, overflowing text and numbers that disagree with the model. Then scrub every move longer than a second in small steps and count how many pixels change per frame. A frame that changes about three times more than its neighbours is a glitch.

He reports a case where, for one frame at one exact angle, a lever turned into a giant black disc: normal frames changed 900 to 1,400 pixels and that one changed over 95,000. No viewer would describe it, but everyone would feel it. After the fix he scanned every frame of the move.

Frame difference scan with Python

import numpy as np, imageio.v3 as iio
frames = [iio.imread(f"frames/{i:05d}.png").astype(np.int16)
          for i in range(start, end)]
diff = [int((np.abs(b - a).sum(-1) > 24).sum())
        for a, b in zip(frames, frames[1:])]
for i in range(1, len(diff) - 1):
    if diff[i] > 3 * max(1, (diff[i-1] + diff[i+1]) / 2):
        print("jump at frame", start + i + 1, diff[i])

Step 7: turn the figure into a video

Interactive figures become video through a seeked tour, not a screen recording. Add a seek(t) function that replays the whole tour from zero to time t, so any frame can be drawn in any order, and a render flag that stops the page's own clock. Draw a cursor that walks to each button and presses it a moment before its step begins. Then record in headless Chrome at 60 fps, piping every screenshot to ffmpeg.

Elvar's reason is worth quoting: "A screen recorder drops frames on slow moves. A seeked tour comes out 60 fps every time." For a Short, set the viewport to a vertical frame from the start and recompose the figure rather than cropping a wide one.

The recording loop

const fps = 60, dur = 36;
await page.goto("http://localhost:8080/figure.html?render");
const ff = spawn("ffmpeg", ["-y", "-f", "image2pipe", "-r", fps, "-i", "-",
  "-c:v", "libx264", "-pix_fmt", "yuv420p", "-movflags", "+faststart",
  "out/tour.mp4"]);
for (let f = 0; f < fps * dur; f++) {
  await page.evaluate((t) => window.seek(t), f / fps);
  ff.stdin.write(await page.screenshot({ type: "png" }));
}
ff.stdin.end();

Step 8: sound

Cutaways suit a soft lo-fi bed under quiet, precise foley: a click on every button press, the hum of a motor, a hiss of steam, a trickle of liquid, placed at the exact seconds of the picture. Elvar scores his in code with named chords and masters to -14 LUFS with the true peak under -1 dB. For a narrated Short, keep the bed well under the voice and let the sound words on screen carry some of the physicality.

Scaling up: one agent per machine, each with a fact to prove

Once one figure works, Claude Code can build others in parallel, one agent per subject, each following the rules of the first: the same look, the same window, one model driving every number. The detail that makes this work is giving each agent a specific fact to prove with a real number behind it. In Elvar's words, an agent told to make a microwave "draws a box with a plate inside"; an agent told to prove the speed of light with a chocolate bar has to draw the standing wave.

Pitfalls

• Drawing before modelling. Numbers that do not come from one model eventually contradict each other on screen.
• Technical-drawing defaults: blue lines, purple shadows, grey everything.
• Lighting every system at once in a glass body. One system per shot.
• Hidden labels. Every readout on a face that nothing covers.
• Screen recording instead of seeking. Dropped frames on slow moves.
• Medical claims. Anatomy for a health app is still health content: keep it educational, source it, and avoid implying diagnosis or treatment.
• Unverified one-shot claims. The published working methods all include a critic pass.

Cost and time

The anatomy skill is free and MIT licensed, and the pipeline (Chrome, Playwright, ffmpeg, Python) is free. The cost is Claude usage and review. Elvar describes getting a first working machine in about ten minutes for a simple question; the critic pass and the video recording add time, and so does getting a model right for anything you do not already understand. Budget the longest time for the first figure; the look, the recorder and the scanner are reusable after that.

Doing it in about 3 minutes with WhatToUpload Video Studio

Interactive 3D cutaways are not a Video Studio style today. What is live: Diagram explainer, Kinetic type and Ink stickman, with more being added. For a "how does it work" video, Diagram explainer is the closest: you type the question in one sentence, Claude writes the script and storyboard, our renderer draws the diagram on the narration, ElevenLabs voices it and captions and sound are timed, in about three minutes.

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