Product & adsAmirMušić @AmirMushich2026-11-150:10

Machine-vision product inspection film

Views
60.5K
Likes
1.3K
Replies
68
Saves
1.1K

A 9.6-second vertical product film made entirely in code, showing an object being inspected, stressed, recovering, and looping. The creator used Claude Code and Blender with Cycles rendering.

Full prompt14,968 chars

# OBJECT STROBE: a product film built entirely in code

> Paste this into Claude Code in an empty folder. Replace `[OBJECT]` once, in the line below. Nothing else needs editing.

**OBJECT = [OBJECT]**

You are the technical director and the art director on a 9.6-second vertical loop for Instagram Reels. The hero is
[OBJECT], modelled entirely in code, with no imported models, no stock assets, no logos and no brand names. The film reads as the
output of a machine-vision system diagnosing [OBJECT]:
- the object comes apart and is inspected part by part;
- it goes back together and is pushed past its limit;
- it recovers and settles into one clean hero frame that loops into frame 0 without a seam.

Under the analysis graphics, each part strobes between three passes: **solid** (finished material), **glass**
(dispersive x-ray), and **field** (a simulation plot of the one physical quantity that matters to [OBJECT]).

Work like a studio, not like a demo: every decision below has a reason, and every number on screen has to be true.

---

## 0. How you work

- Work only inside this folder. Keep scripts in `scripts/`, frames in `renders/`, finished files in `deliver/`, notes in `board/`.
- **Every frame is a pure function of its frame number.** No accumulated state and no randomness without a seed. Any frame
can be re-rendered alone and match its neighbours.
- **One GPU, one render.** Never run two Blender renders at once. Run anything longer than two minutes in the background.
- **Ask before installing software, downloading fonts or spending money.** Say what, from where and how big.
- **Show, then continue.** At each checkpoint (★), build a contact sheet and show it to me before going on:
- every 6th frame with frame numbers burned in;
- 100 % crops where detail matters.
- Write a `README.md` as you go: what each script does and the exact commands to reproduce the result.

## 1. Preflight

Check, report in one table, and fix what's missing (after asking):

| Need | Check | If missing |
|---|---|---|
| Blender ≥ 4.2 (needs the *Khronos PBR Neutral* view transform) | `blender --version`. On Windows also try `C:\Program Files\Blender Foundation\*\blender.exe`; on macOS `/Applications/Blender.app/Contents/MacOS/Blender` | `winget install BlenderFoundation.Blender` / `brew install --cask blender` / the official .tar.xz from https://blender.org/ on Linux |
| GPU for Cycles | in Blender's Python: `cycles` prefs `get_devices()`; prefer OPTIX > CUDA > METAL > HIP | CPU works: halve the samples, render at 50 % first, and tell me the time estimate |
| ffmpeg | `ffmpeg -version` | winget `Gyan.FFmpeg` / brew `ffmpeg` / apt `ffmpeg` |
| Python 3.10+ with numpy, opencv-python, pillow | make a local `.venv`, install there, never globally | — |
| Fonts: **Fira Mono** (data) and **Space Grotesk** (tags), both SIL OFL from Google Fonts | look in system or user font folders | ask, then download into `fonts/` and load them by path |

Then render one 540×960 test frame of a cube with the final render settings. Report the device and seconds per frame,
and project the full render time before you build anything.

## 2. Study the object ★

Before modelling, write `board/OBJECT.md`:

1. **Anatomy.** List 25–50 real parts of [OBJECT] with their real names: housings, inner mechanism, fasteners, seals, the
small parts people never see. Give each one:
- a group (shell / core / small);
- a primary material;
- an **explode vector** (direction and distance along the object's natural assembly axis; large shells travel farthest).
2. **The field.** Pick the ONE physical quantity [OBJECT] truly lives with:
- heat for an engine part;
- load for a structure;
- pressure or flow for a valve or a lung;
- charge for a battery;
- vibration for a speaker.

Name it, give it a unit, a realistic working range and a **limit**. This becomes the story.
3. **The story in four beats**, specific to [OBJECT]:
- cold, at rest;
- working, the field rises in a front across the object, from source to far end;
- **over the limit**, the most extreme frame of the film;
- recovery, a front running back.
4. **Proportions.** Overall size, key diameters and thicknesses, from real-world references you know. Turn them into one
constants table that all geometry reads from.

## 3. Build ([OBJECT] in code)

- Model with signed distance functions in numpy and mesh them with surface nets plus a few Newton steps onto the surface
(crisp edges, no blobby marching-cubes look).
- Use smooth unions for cast parts, hard booleans for machined ones.
- Use real threads on fasteners.
- Use bpy only for assembly and materials.
- Each part is its own object. Each one stores custom properties: `xv` (explode vector), `grp`, `seed`, `tbase` (field
value 0–1) and `hamp` (field noise amplitude).
- Cache SDF results to disk. Decimate large shells to a sane vertex budget (≈ 3 M vertices total is fine).
- **Hero asset bar:** sculpt-level detail on the parts the camera dwells on. Detail density here buys more than more parts:
bevels, bosses, ribs, casting seams, machined faces. Do not show a primitive blockout as the hero.
- ★ Look-dev sheet: four configurations (assembled / exploded / core only / close-up) × three passes, rendered at 50 %.

## 4. Look

- **One `Strobe` shader node group** on every part, switched per object through Attribute nodes (OBJECT type): `st` 0 solid,
1 glass, 2 field.
- **Glass:** three Glass BSDFs on R, G and B at IOR ≈ 1.47 / 1.51 / 1.57, added together. This is cheap dispersion with
rainbow edges.
- **Field:** object-space 4D noise around `tbase`, plus a radial and an axial term, fed through one colour ramp. Emission
rises with the field value, so hot parts glow and cold ones read as a scan.
- **The field palette has two hues, never a rainbow:**
- cold: navy → cobalt → ice;
- an unlit dark band between them;
- hot: ember → red → orange → near-white.

No green and no yellow-green: they read as engineering software, not as a film. Define the ramp once (sRGB hex) and use
the same ramp in the shader, the legend and every inset. In the cold acts, damp the noise so the scan stays blue.
- Studio world: dark ground, two or three hard softboxes. Camera and transmission rays see a pale environment, so the glass
reads.
- **Film transparent.** Backdrops are composited later, which lets the backdrop change per act.
- Khronos PBR Neutral view transform, exposure −1, 16-bit RGBA PNG.

## 5. Timeline: 288 frames = 6 bars at 150 BPM

One beat is 12 frames and an eighth is 6. **Every cut lands on an eighth.** Act lengths:

| frames | act | configuration | what happens |
|---|---|---|---|
| 0–11 | acquire | assembled, glass ghost, **light** backdrop | the hook: the most beautiful material on frame 0 |
| 12–53 | separation | explode flight | outer parts leave first, small inner parts follow; ease-out, no overshoot |
| 54–89 | inspection | exploded, slow drift | **one continuous shot** that keeps the flight's framing; only materials strobe |
| 90–131 | core lock | close-up on the heart part, outer shells hidden | strip light along the edges, f/1.4 depth of field, three field pulses on beats |
| 132–167 | reassembly | exact reverse order | inner parts seat first, shells close last; the camera follows the shells |
| 168–215 | working | assembled | the field front runs source → far end, on the same curve the graphics draw |
| 216–245 | **limit** | assembled | the extreme of the film: everything in the field pass, an alarm flicker on the beat (2.5 Hz) |
| 246–269 | recovery | assembled | a front runs back; parts return to the solid pass one by one |
| 270–287 | clean | assembled, solid, **light**, **no graphics** | the product alone; framing, drift and rotation run into frame 0 |

- Material states are random only in the diagnostic acts (blocks of 1–4 frames, seeded per part). In the story acts they
are **deterministic**: a part's pass follows the front.
- **Never intercut configurations that read as different assembly states.** Hold one configuration per act.
- Acts 168–269 are **one continuous camera move**: one slow push and orbit, with no cuts inside the story.

## 6. Camera and motion

- A fixed shot per configuration, with the object's main axis at about −27° on screen and a low, slightly heroic angle.
- **Auto-framing:** project a subsample of the real mesh vertices (not bounding boxes) and fit the lens to a fill target.
Re-aim at the visual centre, and compute it once per act so repeated shots match.
- Place the subject 70 px above centre: the Reels caption covers the bottom.
- Motion blur from keys at f−0.25, f and f+0.25, computed with that frame's own act, so nothing smears across a cut.
- **Seam math, not eyeballing:** after the render, export each part's projected 2D box per frame. Measure the spread
(the mean distance of the part centres from their centroid) across every act boundary.
- A jump over 2 px means a stutter. Fix it in the camera, not in the edit.

## 7. Render ★

- Run `--track` (timeline JSON) and `--track2d` (per-frame part boxes, depth, pass, field value). Then render all
frames with Cycles at 128 samples, adaptive threshold 0.03, OptiX denoise.
- Frames 0–11 are the hook: render them at 512 samples with threshold 0.01. Grain in the glass at 100 % is not acceptable.
- Render low-res tests of the extremes first (frames 0, 110, 200, 230, 262, 280). Judge the palette on its real backdrop
before spending the full render.

## 8. The vision layer (graphics in Python)

The graphics are diegetic: they are the machine's own readout, never captions or decoration. Composite them in numpy and
PIL over the raw RGBA frames.

- **Two backdrops only:** light for frames 0–11 and the clean beat, dark for the whole diagnosis.
- On light, the object casts a soft offset shadow plus a contact shadow.
- On dark, glowing parts spill a large, warm, blurred glow onto the ground.
- Add a touch of bloom and chromatic aberration, and one **static** grain texture (grain that changes every frame looks cheap).
- **Blend modes:** white vectors use **Exclusion**, so they invert what is under them; apply this to some elements, not
all. Over mid-grey, where Exclusion disappears, the ink is picked from the actual pixels under each label.
- **The safe band** (1080×1920): everything readable lives in y 250–1500 and clears the action column on the right
(x > 930 for y 1000–1500).
- **Type:**
- Fira Mono 24 / 28 for data, Space Grotesk 34 for part names;
- Regular weight only (bold reads cheap);
- 2 px lines, 4 px for the lead line.
- Labels never overlap: a placed label shifts, or it drops.
- **One lead graphic per act:**
- acquire: a dashed hull filling in;
- separation: multi-object tracking with velocity labels and short trails, plus a curved dashed node web;
- inspection: segmentation boxes on a 30 px grid, with the part names;
- core lock: crosshair, lock box, a thermal inset and a 1-bit dithered edge inset;
- reassembly: twelve rays converging on the seat point;
- working: the front line;
- limit: the alarm plate;
- recovery: the recovery front;
- clean: **nothing**.
- **Glitch with purpose:** datamosh, slice, RGB split or pixel-sort, only *inside* tracked boxes, held for 2–3 frames.
Never full frame. The bars must sample the part itself, never empty background.
- **Invert slap:** invert, then black and white, then contrast 1.5. Three frames on, three off, three on, at the separation,
the working start and the limit. **One polarity throughout:** the object as a white silhouette on black, graphics white.
- **Red belongs to the alarm.** It appears only after the limit is truly crossed. Everything else is white.
- **One scale for every number:** each temperature, pressure or load on screen is computed from that part's real field
value through one function, for example `T = min + (max − min) · v^1.6`.
- The legend, the insets, the log and the tags all agree.
- The limit act is the highest reading of the film.
- Parts the recovery front has passed read as recovered.
- IDs are consistent everywhere.
- **The log:** a typewriter with a scrambled leading edge, top left. Lines carry live values, not invented ones.

## 9. Sound (synthesised from the timeline, numpy only)

Three layers with roles:
- **mechanics:** impacts, the ejection roll, seat clicks, the lock;
- **machine voice:** the characteristic sound of [OBJECT] at work. Its pitch follows the real state curve from the
timeline, about two octaves over the working act;
- **data:** blips on log lines, ticks. Keep it about 18 dB under the other layers.

Events:
- a downbeat sound on frame 0;
- the separation as a roll, with three accents on the largest parts;
- near-silence in the inspection;
- three pulses with the core lock;
- a reversed swell into the lock at frame 168;
- one signature double hit for every slap;
- at the limit, a warning on its first beat and the alarm from the frame the limit is crossed;
- a release sound into the recovery;
- one soft air hit when the backdrop turns light.

Render the score twice in a row and keep the second pass, so tails wrap into frame 0. For phones, add harmonics so the
low end survives small speakers, and keep everything under 200 Hz centred. Master with gain plus a limiter to −14 LUFS
integrated and −1.5 dBTP. Check the mono fold-down.

Also write `deliver/cues.csv`: time, frame, bar.beat, event, what. Someone may want to redo the sound by hand.

## 10. Finish and delivery

- Encode with an explicit BT.709 conversion (`scale=out_color_matrix=bt709:out_range=tv`) and write all three colour tags
into the stream (`h264_metadata` bitstream filter). Untagged files shift gamma on phones.
- Deliver:
- `*_ig.mp4`: two-pass H.264, 16 Mb/s, AAC 320k;
- `*_master.mp4`: CRF 15;
- `*_clean.mp4`: the same film with no graphics and no slaps, for clients;
- `audio/`: the mix and its stems;
- `cues.csv`;
- five 4K stills (hook, close-up, limit, recovery, clean), composited on their own backdrops;
- a 1080×1920 cover that holds up as a 3:4 grid crop.

## 11. Quality gates (measure them and report the numbers)

1. **Seams:** spread jump ≤ 2 px at every act boundary; the reassembly spread decreases monotonically.
2. **Loop:** the object's bounding box on frames 287 and 0 matches within 2 px. Only the material changes at the loop.
3. **Flashes:** at most 3 full-field luminance flips in any second (aim for far fewer).
4. **Compression:** re-encode at 720p and 2.5 Mb/s, as the platform will, and check that every label is still readable.
5. **Safe band:** draw the Reels UI zones over six frames; no readable element inside them.
6. **Truth:** read every number on six frames aloud against the story. A reading that contradicts the picture is a bug.
7. **Taste:**
- one hero per frame;
- nothing static for long;
- nothing jittering at random;
- no green;
- no red before the alarm;
- no text outside the HUD;
- no logos.

Finish with a short report: the files, the measured gates, render time and anything you could not verify.

Source: the creator's reply under the post. Kept in its original language, unedited.

Want more prompts like this one?

Get the 50 most-viewed Claude 5.5 video prompts on one page: the full original text, the creator and the post it came from. We'll only email you when there's a new prompt worth trying. Unsubscribe anytime.

Tools the creator mentioned

Claude CodeBlenderFableCyclesPythonNumPyOpenCVPillow

Original post: https://x.com/AmirMushich/status/2121982602122760352

All works are open data at GitHub · awesome-opus-5.5-video.

Model attribution is as stated by the creator and was not independently reproduced. View counts are a snapshot from 2026-11-19. The work belongs to its creator; DM @GoSailGlobal on X for corrections or removal.

More product & ads

Related articles