Skip to content
Back to search

cutaway

SkillWorks with Claude CodeGitHub

Build a robotic cutaway of any object or creature from one reference image - a three.js scene written entirely in code that takes itself apart on camera, a page with a button for every part, and a 60 fps film with a synced procedural score. Claude matches the build to the picture, grades it line by line, measures its density and proportions, and films it only after the user approves the still. Use when someone hands over a picture of a robotic animal, machine or device and wants it built in 3D, opened up part by part, or recorded; or asks for a "cutaway", an "exploded view", a "robot animal simulator" or "make this image a 3D model that comes apart".

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/nyxera0x--cutaway/badge.svg)](/listings/nyxera0x--cutaway)

HTML

<a href="/listings/nyxera0x--cutaway"><img src="/api/listings/nyxera0x--cutaway/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add Nyxera0x/cutaway -g -a claude-code

Then, once, in the installed folder:

npm install && npx playwright install chromium

You need Node.js 20 or newer. For the video you also need `ffmpeg`, and for the sound Python 3.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 172 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: cutaway
  3. description: Build a robotic cutaway of any object or creature from one reference image - a three.js scene written entirely in code that takes itself apart on camera, a page with a button for every part, and a 60 fps film with a synced procedural score. Claude matches the build to the picture, grades it line by line, measures its density and proportions, and films it only after the user approves the still. Use when someone hands over a picture of a robotic animal, machine or device and wants it built in 3D, opened up part by part, or recorded; or asks for a "cutaway", an "exploded view", a "robot animal simulator" or "make this image a 3D model that comes apart".
  4. ---
  5. # Cutaway
  6. One picture in, one object out: built from code, opened part by part, filmed. The visitor sees the object move, a cursor presses a button, and that part comes apart under its own camera while live cards around it react. The same code records the film frame by frame, with a score built on the same timeline.
  7. `SKILL_DIR` below is the folder this file lives in. Builds and renders go to `./cutaway-out` of the folder you run from.
  8. ## First run
  9. ```
  10. cd "$SKILL_DIR" && npm install && npx playwright install chromium
  11. ```
  12. The pages need nothing else. The video needs `ffmpeg` on PATH and the score needs Python 3 (standard library only). Set `FFMPEG`, `PYTHON` or `CHROMIUM` to point at other binaries.
  13. ## The 3 examples
  14. Build one, open the HTML, watch it take itself apart. Start a new object from the example whose body is closest.
  15. | | The object | Its parts | Worth stealing |
  16. |---|---|---|---|
  17. | `tarantula-*` | A robotic tarantula on 8 bristled legs, a glass abdomen full of lit coils. | Optics, a front leg coming apart on its servos, the abdomen cage opening, the head plates lifting; two jumps. | A walking body: an alternating tetrapod gait integrated from velocity keys, a jump with a crouch and a tuck. |
  18. | `piranha-*` | A deep-bodied robotic piranha with 2 rows of glass fangs and a glass flank over drive gears. | The eye unscrewing in macro, the tail stalk telescoping, the glass flank opening from above, the jaw dropping from below. | One camera per beat aimed at its own part; a mirrored scene; a lunge at the lens. |
  19. | `wasp-*` | A robotic wasp with frosted wings, a telescoping abdomen and a glass stinger. | Optics, a wing pulled out of its hinge and turned over, thorax gears, the abdomen telescoping. | A slow-motion explode as a warp of film time into scene time; a dive in from above and a climb out of the frame. |
  20. Each comes in 3 folders: `<name>-shared/` holds the object, `<name>-film/` the full film (it also opens as a looping page), `<name>-demo/` a 10-second version with its own script.
  21. ```
  22. node "$SKILL_DIR/sims/build.mjs" piranha-film # → cutaway-out/dist/piranha-film.html, offline, ~900 KB
  23. node "$SKILL_DIR/sims/build.mjs" # all of them
  24. ```
  25. ## The method
  26. The 4 files in `docs/` are the method. Read them before the first object, and keep `docs/JOB_DESCRIPTION.md` open the whole time.
  27. | File | What it holds |
  28. |---|---|
  29. | `docs/JOB_DESCRIPTION.md` | The brief: the look, the order of work, the camera, the film, the short version. Every correction the user gives goes into it, one line per mistake. |
  30. | `docs/CHECKLIST.md` | How to write 10 to 12 numbered lines on what one picture stands on, a template and a full example. |
  31. | `docs/PROMPTS.md` | Every prompt, from the reference image to the sound. |
  32. | `docs/LESSONS.md` | Every mistake so far and the line it added to the brief. |
  33. The order, every time:
  34. 1. **The reference.** One picture. If the user has none, generate one with the prompt in `docs/PROMPTS.md`. It sets the look and nothing else: never import it, rebuild it.
  35. 2. **Measure the picture.** Body height, head length, jaw or limb length as shares of the body length. Dark-pixel share (luma under 80) in its bounding box.
  36. 3. **Write the checklist** for this picture before the first line of code.
  37. 4. **The still loop.** Build, render a still posed like the reference, stack reference | still | an approved still, plus the stack at 900 px wide, grade every line yes / partial / no against the picture. **Stop after round 2 and show the user.** Nothing gets filmed until they say yes.
  38. 5. **The film.** Port the example with the closest body 1:1: its tour, its beat times, its moves, distances scaled. Change the body only. Give every part its own camera.
  39. 6. **The short version.** Its own script, never pieces of the long film.
  40. 7. **Render and score.**
  41. ## How an object is built
  42. One folder per object, split by job. The examples follow this exactly:
  43. | File | Job |
  44. |---|---|
  45. | `spider.js` / `piranha.js` / `bee.js` | The body, built from code: shells, gears, pistons, hoses, lenses, membranes. Every part that comes apart is its own group with a named anchor; `pose(state)` sets the whole object for one moment. |
  46. | `parts.js` | The shop: materials (gloss white shell, accent, graphite, black, steel, lens, glass) and shape helpers. `PAL` holds the colours. |
  47. | `stage.js` | The studio: paper backdrop, lights, soft floor shadow, post. `frame(cam)` draws one frame. |
  48. | `tour.js` / `tour_bee.js` / `tour_v2.js` | The film as functions of time: each act's clock, the flight or walk, the explode, every camera, the telemetry for the page. |
  49. | `sim_green.js` | The wiring: state for t → pose, flight, camera, page. Applies the green look. |
  50. | `../green/` | The page around every object (title, pill buttons the cursor presses, a section list, 4 cards, labels with leaders) and the green look (`look.js`). |
  51. | `score.py` | The sound on the film's timeline. |
  52. For an object outside `SKILL_DIR`, make a folder with a `main.js` and import the kit by name: `import {runSim} from 'cutaway-kit/runtime.js'`. Build it with `node "$SKILL_DIR/sims/build.mjs" ./my-object`.
  53. ## Rules that decide whether it works
  54. 1. **Start from the picture, never from imagination.** Asked for a robot animal with nothing to match, the model returns a generic toy. With a picture and a checklist it rebuilds what is in front of it.
  55. 2. **Port the closest approved film.** A new body on an existing choreography works; a new body on a new choreography is twice the rounds. Flag an object with no close body before starting.
  56. 3. **Measure, don't eyeball.** Features pass the checklist while the whole reads as a tidy white diagram. Dark share must reach 0.8 of the reference's; proportions must match within a few hundredths.
  57. 4. **One main set of limbs.** Legs, or wings, or tentacles. Two systems fighting for the same half second is noise.
  58. 5. **Dense core, plates with gaps.** Break white surfaces into separate curved plates in 3 sizes with gaps over the mechanism. A long smooth shell reads as a toy however many rounds it gets.
  59. 6. **Every beat its own camera.** Aim at the part itself, from its own side and height, and push in while it hangs open. Check with `sims/green/cam_track.mjs`: if az, el and distance barely move between beats, the film looks parked.
  60. 7. **Review after round 2, 2 objects at a time.** A note after round 2 changes the outcome; after round 6 it only costs tokens.
  61. ## The green look
  62. `sims/green/look.js` turns any object green without touching its code: set `PAL.orange` and the paper before the build, then call `retint(root)` after the build and after every pose. It handles material colours, emissive glows, HDR glow colours above 1, colours a pose rewrites every frame, lights and vertex colours. `SHIFT` moves the subject into the page's 3D window. Before a render, run `node sims/green/probe_warm.mjs <entry> <t> <global>`: it lists any warm colour left.
  63. ## render(t) contract
  64. ```js
  65. import {runSim} from '../kit/runtime.js';
  66. const DEFAULTS = {duration: 20, fps: 60, hud: {enabled: false}, director: {enabled: false}};
  67. runSim(DEFAULTS, async ({cfg, canvas, capture}) => {
  68. // build the scene, precompute anything stateful
  69. return {render(t) { /* draw frame t from scratch */ return {}; }, resize() {}};
  70. });
  71. ```
  72. - `render(t)` is pure: no `Math.random` (use `rng(seed)` from `kit/util.js` at setup), no `Date`, no state carried between frames. Capture calls it at arbitrary times.
  73. - Anything integrated over time (a gait, the gears' busy clock, a speed ramp) is tabulated at load; `render` only reads the tables.
  74. - Every beat goes into `<name>-film/timeline.json` in seconds. The score reads the same file.
  75. - A short version may run its scene faster than the film: `{"duration": 11.3, "film": 10.0}` plays 11.3 s of scene in 10 s.
  76. - Frame 0 is the thumbnail. It must already show the object big, front 3/4, moving.
  77. ## Commands
  78. ```
  79. node "$SKILL_DIR/sims/build.mjs" piranha-film
  80. node "$SKILL_DIR/sims/capture.mjs" piranha-film --size 1600x900 --dpr 1.2 --stills beats --cols 4 --out cutaway-out/piranha-beats.png
  81. node "$SKILL_DIR/sims/capture.mjs" piranha-film --size 1600x900 --dpr 1.2 --still 9.4 --out cutaway-out/piranha-9.4.png
  82. node "$SKILL_DIR/sims/capture.mjs" piranha-film --size 1600x900 --dpr 2.4 --out cutaway-out/piranha-4k.mp4
  83. python "$SKILL_DIR/run_sfx.py" "$SKILL_DIR/sims/piranha-shared/score.py"
  84. ffmpeg -y -i cutaway-out/piranha-4k.mp4 -i cutaway-out/piranha-score.wav -map 0:v -map 1:a -vf scale=1920:1080:flags=lanczos -c:v libx264 -crf 16 -pix_fmt yuv420p -c:a aac -b:a 256k -shortest -movflags +faststart cutaway-out/piranha.mp4
  85. ```
  86. For a demo whose scene runs faster than its film, score the scene and stretch the sound by the same factor:
  87. ```
  88. TL="$SKILL_DIR/sims/piranha-demo/timeline.json" OUT=cutaway-out/piranha-demo-scene.wav python "$SKILL_DIR/run_sfx.py" "$SKILL_DIR/sims/piranha-shared/score.py"
  89. ffmpeg -y -i cutaway-out/piranha-demo-scene.wav -af atempo=1.12 cutaway-out/piranha-demo-score.wav
  90. ```
  91. `--size` is the CSS layout and `--dpr` multiplies it: 1600 x 900 at 1.2 gives 1920 x 1080, at 2.4 gives 4K to bring down to 1080p (thin veins stay sharp). Capture prints the GPU it got; a software renderer means the GPU flags in `paths.mjs` did not take.
  92. ## Review loop
  93. You cannot watch the video; you can look at frames. Never report an object as done without reading sheets of the current render.
  94. 1. `--stills beats`: one tile per timeline beat, 0.3 s after it, each labelled `t=`.
  95. 2. Read every tile against the checklist below.
  96. 3. Zoom in: `--stills every:0.2 --from A --to B` for a transition, `--still T` for one full frame.
  97. 4. `node sims/green/cam_track.mjs <entry> <global>` prints the camera every 0.5 s; `node sims/green/anchors_dump.mjs <entry> <global>` prints the parts' rest points to aim cameras at.
  98. 5. Fix, rebuild, go back to 1. Stop when a full pass finds nothing.
  99. 6. Final: `node "$SKILL_DIR/sheet.mjs" --video <final.mp4> --timeline <timeline.json>` and read that too.
  100. Checklist:
  101. - **The object.** Every part that comes apart goes back where it was; nothing passes through anything; the cards match the motion.
  102. - **Composition.** The opening part fills the frame; the rest may run off. Labels never cover the part they name.
  103. - **The look.** No warm colour left (`probe_warm.mjs`). Green only as lines and glows, never dots.
  104. - **Camera.** A new side, height or distance at every beat. No beat parked.
  105. - **Timing.** A part opens in about 1 s, holds, closes in 0.5 s; a new beat every 2 to 3 s.
  106. ## three.js traps the examples already hit
  107. - A glow colour above 1 (an HDR `MeshBasicMaterial`) breaks `getHSL`: read and write it at unit peak.
  108. - A colour the pose rewrites every frame comes back each frame: retint whatever changed since the last write.
  109. - Colours baked into vertex attributes ignore the material: retint the `color` attribute too.
  110. - `smoothstep(a, b, x)` with `a > b` returns 0 on Windows (ANGLE/D3D). Write `1.0 - smoothstep(b, a, x)`.
  111. - One NaN pixel blacks out the whole frame through bloom. Clamp every `pow()` base in a shader.
  112. ## Sound
  113. `sfx/` synthesises every sound in pure Python (48 kHz, reproducible) and reads the film's timeline, so sound cannot drift out of sync. `python "$SKILL_DIR/run_sfx.py" --list` shows the generators. `sfx/score_kit.py` has the bed and accents the 3 scores use: a chord bed with soft drums, a pad, airy whooshes, clicks and ticks.
  114. - Every time comes from the timeline, never a typed number.
  115. - Mastering is automatic: −14 LUFS, true peak ≤ −2 dBFS.
  116. - Accent, never narrate: a quiet click per button, a short accent on every part that moves, continuous motion silent.
  117. ## Taste, with numbers
  118. - Frame 0: the front 3/4 hero view, the object big and already moving.
  119. - A beat every 2 to 3 s. Visible wing beats 1.5 to 2.5 Hz; faster only as a motion-blurred fan.
  120. - Bristles and spikes 0.15 to 0.25 of the limb's thickness.
  121. - The object fills 60-70% of the 3D window at rest; the opening part fills the frame.
  122. - One accent colour, and it marks what is moving right now.
  123. ## Credits
  124. The kit, frame capture, sfx engine and review rules come from [whaleyxbt/claude-motion](https://github.com/whaleyxbt/claude-motion) (MIT). The recorded samples are CC0 from Freesound, trimmed by [Barty-Bart/motion-graphics](https://github.com/Barty-Bart/motion-graphics) (MIT); sources in `sfx/samples/SOURCES.md`.
README.md · README · 76 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # cutaway
  2. A Claude Code skill that turns one picture into a 3D object that takes itself apart.
  3. Give Claude an image of a robotic animal, a machine or a device. It rebuilds it in three.js, every shell, gear and fang written as code, checks the build against the picture line by line, and films it: a cursor presses a button, that part comes apart under its own camera, then the whole object explodes and snaps back together.
  4. ![Theraphos TH-8 robotic tarantula](docs/tarantula.gif)
  5. | Serrasal PX-7 robotic piranha | Vespion VX-9 robotic wasp |
  6. |---|---|
  7. | ![Serrasal PX-7 robotic piranha](docs/piranha.gif) | ![Vespion VX-9 robotic wasp](docs/wasp.gif) |
  8. ## Install
  9. ```
  10. npx skills add Nyxera0x/cutaway -g -a claude-code
  11. ```
  12. Then, once, in the installed folder:
  13. ```
  14. npm install && npx playwright install chromium
  15. ```
  16. You need Node.js 20 or newer. For the video you also need `ffmpeg`, and for the sound Python 3.
  17. ## Use
  18. Give Claude Code a picture and ask in plain words:
  19. > Here is a robotic mantis. Build it as a 3D object I can take apart, and stop at the still so I can check it.
  20. > Turn this image of a robot crab into a 20-second film where every part comes apart.
  21. > I approved the still. Film it the way the piranha example is filmed.
  22. No picture yet? `docs/PROMPTS.md` has the prompt that generated ours.
  23. Or open one of the 3 examples first:
  24. ```
  25. node sims/build.mjs tarantula-film # cutaway-out/dist/tarantula-film.html
  26. node sims/build.mjs piranha-film
  27. node sims/build.mjs wasp-film
  28. ```
  29. ## How it works
  30. 1. **One reference picture** sets the look. Claude reads it and rebuilds it; it never imports it.
  31. 2. **A checklist for that picture**: 10 to 12 numbered lines Claude grades yes, partial or no every round.
  32. 3. **Measured, not eyeballed**: the share of dark mechanism and the proportions, both against the picture.
  33. 4. **A still first.** Claude stops after round 2 and waits for your yes. Nothing gets filmed before it.
  34. 5. **The film** reuses the example with the closest body 1:1 and changes the body only. Every part gets its own camera.
  35. 6. **A 10-second version** gets its own script, its own opening and its own exit.
  36. The whole method is in `docs/`, written so you can follow it with or without the code.
  37. ## What is inside
  38. | | |
  39. |---|---|
  40. | `SKILL.md` | What Claude reads: the order of work, the rules that make it look right, the review loop. |
  41. | `docs/JOB_DESCRIPTION.md` | The brief Claude reads before every object. Your corrections go into it. |
  42. | `docs/CHECKLIST.md`, `docs/PROMPTS.md`, `docs/LESSONS.md` | The checklist format with a full example, every prompt, every mistake and the line it added. |
  43. | `sims/tarantula-*`, `sims/piranha-*`, `sims/wasp-*` | 3 complete objects. `-shared` is the object, `-film` the full film, `-demo` the 10-second version. |
  44. | `sims/green/` | The page around every object and the green look, plus 3 review tools: leftover-colour probe, camera track, part anchors. |
  45. | `sims/kit/` | Runtime, stage, shader warm-up. |
  46. | `sims/build.mjs` | Bundles an object into one HTML file, three.js and fonts inlined. |
  47. | `sims/capture.mjs` | Renders the film frame by frame to a 60 fps mp4, or to review sheets of stills. |
  48. | `sfx/`, `run_sfx.py` | Procedural sound on the film's timeline, mastered to −14 LUFS. |
  49. ## Credits
  50. Built on [whaleyxbt/claude-motion](https://github.com/whaleyxbt/claude-motion) (MIT): the runtime, frame capture, sound engine and review rules come from there. Recorded samples are CC0 from Freesound, prepared by [Barty-Bart/motion-graphics](https://github.com/Barty-Bart/motion-graphics); sources in `sfx/samples/SOURCES.md`.
  51. MIT licence.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.