Skip to main content
prompt GP ChatGPT

reference-to-nodes-prompt — Claude Code prompt: editable Blender nodes

reference-to-nodes-prompt is a Claude Code prompt that turns a reference clip or image into an editable Blender node graph.

MIT ★ 101 updated 2026-10-21

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add gokayfem/video-to-blender
/plugin install video-to-blender@video-to-blender
Open on GitHub

What reference-to-nodes-prompt does

It hands the job to the procedural-blender-nodes skill: the agent reads that skill's SKILL.md first and follows its steps. Geometry Nodes carry form, layout and motion, Shader Nodes carry materials, and a compositor graph handles atmosphere. Python assembles the graph through nodekit, and the graph is what comes back, not a script and not a baked mesh.

A block of fields gets filled before sending: the reference (video link or path, images, an image-sequence folder, or a written description), its kind, an output name that sets paths such as <name>/build.py and <name>/<name>.blend, the geometry the system should run on, what must be kept and what can be skipped, the render target with resolution, fps and duration, and the Blender build with its path. Leave a line blank and the agent measures or proposes the value.

The order of work is written in too: a measured breakdown of the reference goes to docs/REFERENCE.md and docs/reference_params.json, contracts go to AGENTS.md, then milestones with renders and a difference list after each. Blender 5.2.x and the procedural-blender-nodes skill are both required, because the opening line tells the agent to read that skill's SKILL.md.

What it helps with

  • rebuild a clip as an editable node graph instead of a baked mesh
  • split a scene across geometry nodes, shaders and compositing
  • measure sizes and colours from footage before modelling anything
  • run the same node groups on inputs the reference never showed
  • keep the graph and a written breakdown of the reference side by side

Example prompts for the agent

  • Read the SKILL.md of procedural-blender-nodes and rebuild reference.mp4 as an editable Blender node graph
  • Fill the prompt fields for city.mp4: output name city, EEVEE as the render target, keep the facades, skip the birds
  • Print the field block so I can paste the Blender path and the frame folder

How to install reference-to-nodes-prompt

1Plugin marketplace

/plugin marketplace add gokayfem/video-to-blender
/plugin install video-to-blender@video-to-blender

2Manually: put the files in place

.claude/commands/reference-to-nodes-prompt.md

Questions about reference-to-nodes-prompt

How do I install reference-to-nodes-prompt in Claude Code?

Add the marketplace with /plugin marketplace add gokayfem/video-to-blender, then install the plugin: /plugin install video-to-blender@video-to-blender. The prompt file sits at .claude/commands/reference-to-nodes-prompt.md.

What does reference-to-nodes-prompt do?

It asks the agent to rebuild a reference as a Blender node system with the procedural-blender-nodes skill: geometry nodes for form and motion, shader nodes for materials, a compositor graph for atmosphere. Python builds the graph through nodekit, and the graph itself is the deliverable.

What do I need for reference-to-nodes-prompt to work?

Blender 5.2.x with a path to the build, plus the procedural-blender-nodes skill installed, since the prompt opens by telling the agent to read its SKILL.md.

Source text

reference-to-nodes-prompt.md · MIT
# Prompt: recreate a reference as an editable Blender node system

Use the **procedural-blender-nodes** skill (read its `SKILL.md` first and follow its workflow) to recreate the
reference below as a native, editable Blender node system: Geometry Nodes for form, layout and motion, Shader
Nodes for materials, a compositor graph for atmosphere. Python builds the graph through `nodekit`; the
deliverable is the graph, not the script and not a baked mesh.

Fill these in before sending (leave a line blank to let the agent measure or propose it):

- **Reference:** `<video URL or path | image path(s) | image-sequence folder | written description>`
- **Reference kind:** `<video | image | views | sequence | text>`
- **Output name:** `<name>` (files become `<name>/build.py`, `<name>/<name>.blend`, ...)
- **Input the system should run on:** `<a path curve | any mesh | a point set | none (self-contained)>`
- **Must keep:** `<objects, beats or qualities you care about most, or blank>`
- **Allowed to skip:** `<anything you already know you do not want, or blank>`
- **Render target:** `<EEVEE | Cycles>`, `<resolution, fps, duration>`
- **Blender:** `<5.2.x>` at `<path>`

The reference is the visual specification; the graph is an editable explanation built for it, not a recovered
ground truth. Nothing in this document describes the reference's content: you derive it in section 1 and get the
breakdown approved before building.

## 0. Quality bar (read first; overrides anything below that conflicts)

**Done means every check below passes.** A failing check is listed as failing, never as "good enough".

- **Graph quality**
  - Every group and input has a description; inputs have ranges and subtypes; internals are in named frames;
    sub-groups are reusable parts. Zero `check_groups` lint and zero node warnings on every scene.
  - Two builds from nothing produce identical graph dumps.
  - A Primary panel of 6-10 macro controls comes first; every Primary control changes the result visibly over its
    whole range (proved by sweeps).
- **Reuse**
  - The same node groups run on at least three inputs the reference never showed (other curves, meshes, or
    layouts), five seeds, and every preset, with zero warnings and an acceptable result. Limits are written down.
- **Motion** (when the reference moves)
  - Analytic unless the motion needs state, interaction or accumulation (`animation-and-simulation.md`). The choice
    and its reason are stated.
  - Gait or rolling phase is integrated from distance; contacts (feet, wheels, objects at rest) do not slide.
    Prove it with numeric probes, not stills.
  - Secondary motion is spring-damped (lags, overshoots, settles). Wind is a gust envelope with per-piece response.
  - No popping or flicker: frame-to-frame differences are steady over the whole range.
  - A simulation is baked before it is rendered, and determinism is checked.
- **Detail**
  - Every object is built from its parts (a house: walls, openings, roof, chimney; a tree: trunk, limbs, crown).
    An object reduced to its most obvious part fails.
  - Anything covering more than 10 % of the frame shows silhouette, secondary forms and surface detail.
- **Reference**
  - Sizes, counts and distributions are measured, not guessed, and written in one unit (section 2).
  - Colours and light are matched by measurement per region (mean Oklab L, chroma, luma p10/p50/p90), with the
    numbers reported.
  - Every timeline row or view has a side-by-side with the remaining differences written down.

**Process.** Work in milestones (section 7). After each, render, look at every image, list the five biggest
differences, fix, re-render: at least three rounds. Do not stop or summarise while a check fails, and do not
invent content the reference does not show.

---

## 1. Reference breakdown (do this first, then stop for approval)

Write `docs/REFERENCE.md` (and `docs/reference_params.json` for the numbers) before writing any node code. Keep
measurement scripts in `reference/scripts/` so they can be rerun.

**For every reference kind:**

1. **Facts:** source, hash, resolution and aspect; for video: duration, fps, frame count, cuts, whether it loops.
   Verify it is the original (not an earlier reconstruction or a re-encode).
2. **Object inventory:** every object larger than about 2 % of the frame: its parts, shape language, size relative
   to a chosen ruler, position relative to other objects, and where it is best seen.
3. **Distributions, not instances:** for repeated things (houses, trees, props, stones, flags), measure ranges and
   frequencies (width, height, spacing, chance per piece, colour palette), since a generator reproduces
   distributions.
4. **Light and palette:** key direction and colour, fill and shadow colour, sky, haze; sampled sRGB per main
   surface.
5. **Style:** stylised or realistic, edge softness, saturation, grade, bloom, depth of field.
6. **What cannot be reproduced exactly**, and the substitute proposed for each (section 9 decides).
7. **Inconsistencies of the reference** (AI clips drift, morph, change object counts): name them so the system
   does not copy them.

**Video:** the value is over time.
- Timeline every 0.5 s (finer around fast action): time, beat, what the frame shows.
- Motion log: speeds, gait (stride, cadence), pauses, interactions, secondary motion amplitudes, wind; from tracks
  of points over frames (slit-scans, point tracking, autocorrelation for cadence).
- Camera log: height, distance, field of view (state the assumption if it cannot be measured), how it moves.
- Contact sheets and motion strips in `reference/sheets/`.

**Image or views:** the value is across views and within the image.
- Per view: camera position, height and field of view estimated from vanishing points and known sizes.
- Cross-check sizes between views; measurements that disagree are flagged, not averaged away.
- Crops of every object at the largest available size.

**Image sequence** (turntable, time-lapse, frames from a game): treat as video if ordered in time, as views if
ordered by angle; say which.

**Written description:** the value is the spec.
- Rewrite it as a numbered spec: objects with parts, sizes in one unit, counts, distributions, motion, light,
  camera. Mark every number you had to choose as an assumption, with a range.
- Collect 2-4 reference images (or describe the intended look precisely) and get the spec approved before
  building.

## 2. Contracts (write before building; `AGENTS.md` of the project)

- **Units:** 1 unit = the chosen ruler (the main character's height, a door, a metre). Every measurement uses it.
- **Spaces:** the local frame things are modelled in (curve space (s, d, h) through `NK Curve Frame`, surface
  space, piece-local space), and the rotation convention (+X along, +Y left, +Z up).
- **Shared input names:** `Curve`/`Path`, `Time` (seconds; only the top group reads Scene Time), `Seed`, and the
  shared dimensions.
- **Interfaces between parts:** extra outputs (anchor point clouds with typed attributes) and their attributes.
- **Attributes into materials:** `nk_color`, `nk_rand`, `nk_local`, project terms where 0 = no effect.
- **Naming:** project prefix for groups and materials; library groups stay `NK `.
- **Ownership** if several agents build parts in parallel.

## 3. Comparison tooling (before the first milestone)

- **Video:** `scripts/video.py` (extract, side-by-side video, contact sheet) and `scripts/compare.py` (colour,
  structure and motion metrics per screen region over time, with the reference's self-noise floor).
- **Images/views:** render the same camera as each view; crop the same regions; mean Oklab L, chroma, luma
  percentiles, edge density per region.
- **Probes:** stored probe attributes read from the evaluated geometry over frames (contacts, roots, pendulum
  tips), camera positions per frame (`render.py --report`).
- **Diff:** before/after image difference for changes that should not alter the look.

## 4. Build

- Route the subject (`references/subject-routing.md`) and start from the closest template; assemble from the
  library (`nodes_tools.py search`) and add project groups only for what the library lacks.
- One Python module per part family, each exposing `build()` returning its top group; a top modifier group that
  wires the input object, Time and shared inputs, applies the Primary macros and forwards part inputs to
  `"<Part> > <Panel>"` panels (`controls-and-presets.md`).
- Model in local frames and place; instance shared meshes; store per-piece decisions as attributes on piece points;
  realize once at the end.
- Test each part alone (`try_group.py`) on every test input before integrating, then integrate early and judge only
  the full build.
- Structure changes only in the builders; fitting to the reference changes only parameters (defaults, presets,
  light file, camera).

## 5. Animation

Choose analytic or simulation per motion with the decision rule, and state it. Analytic motion keys a timeline
(speeds, events, holds) to the breakdown and is a closed form of `Time`; simulations step with `Delta Time`, are
baked, and are checked for determinism. Cameras live outside Geometry Nodes: a rig on the same path driven by the
same modifier inputs, so retiming the motion retimes the camera.

## 6. Look

EEVEE (or Cycles if required) with AgX; exposure, sun, sky and look fitted by measurement in that order; distance
haze and glow in the compositor on premultiplied geometry; materials tinted by `nk_color` with small procedural
variation (`materials-and-look.md`).

## 7. Milestones

1. **Breakdown, contracts, tooling** (sections 1-3). Stop for approval.
2. **Blockout:** every part as stand-in geometry on the real input, the camera, timing or views in place. Check
   composition against every timeline row or view.
3. **Parts:** each part built from its parts, tested alone on all test inputs.
4. **Motion:** final motion, proved with probes and sequences.
5. **Look:** materials, light, compositor, matched by measurement.
6. **Reference pass:** walk every row or view and every object again; fix the biggest differences.
7. **Reuse pass:** transfers to new inputs, seeds, presets, control sweeps; fix what breaks or record the limit.
8. **Validation:** the definition of done in `references/validation-and-review.md`.

At every milestone: render, look, critique, fix, at least three rounds.

## 8. Variations and transfer

- **Presets:** 4-6 JSON presets that change the character of the result mostly through Primary controls (the
  reference is the empty preset).
- **Sweeps:** every Primary control, start to end, rendered at a moment where its effect shows.
- **Transfers:** the same node groups on new inputs, as extra scenes in the same .blend.
- These prove the result is a system, not a scene. A control or transfer that does not work is reported.

## 9. Simplifications

Allowed without asking: textures replaced by procedural shading; faces left unmodelled when the reference never
shows them; distant objects as simpler instances; background sky as a gradient.

Everything else needs approval first: dropping parts of objects, fewer object kinds, baking the generator instead
of keeping it live, a simulation replaced by analytic motion (or the reverse) against the decision rule, any change
to timing, composition or camera that departs from the reference.

## 10. Deliverables

- `build.py` that builds the .blend from nothing (deterministic) and writes a graph dump (`<name>.graph.json`).
- `<name>.blend`: the reference scene plus transfer scenes, all sharing the same node groups; small because it
  stores graphs, not geometry (except packed bakes, which are listed).
- `presets/*.json`, `light.json` (or equivalent parameter files).
- `docs/REFERENCE.md`, `docs/GRAPH.md` and `docs/CONTROLS.md` (generated by `graph_doc.py`), node-editor
  screenshots (`graph_shots.py`).
- Renders: the reconstruction, side-by-side with the reference, presets sheet, sweeps, transfers.
- `README.md`: how to build and use it, the Primary controls, how it is built, validation results with numbers,
  limitations.

## 11. Honesty rules

- Report measured numbers with what was measured and how; never invent accuracy figures.
- Separate verified, looked at, and not checked.
- Call the result an interpretation where it is one; name the visible differences from the reference.
- Do not claim novelty without a prior-work check.
- List every limit found: inputs that break it, control ranges that degrade, costs per frame, what is baked, what is
  experimental.

© gokayfem · MIT · gokayfem/video-to-blender

Similar prompts

All prompts for Game dev and 3D: Unity, Unreal, Godot, Blender →
gaussian-splat-to-blender-nodes gokayfem gaussian-splat-to-blender-nodes is a Claude Code plugin that guides Blender scene reconstruction from a Gaussian splat using editable geometry and shader nodes. It can also map calibrated capture textures onto the result. ★ 86repo stars scenario-blender-geometry-nodes scenario-labs scenario-blender-geometry-nodes is a skill that builds and debugs Blender Geometry Nodes via Python for procedural modeling, simulations, and 5.2 physics. CX Codex +1 969installs blender-geometry-nodes blender-agent-skills The blender-geometry-nodes Claude Code skill helps build Geometry Nodes setups in Blender. It comes into play for procedural assets, surface scattering, and modifier inputs. CX Codex +1 563installs scenario-blender-hair scenario-labs scenario-blender-hair guides hair and fur grooming in Blender 5.2 using hair curves and Essentials nodes. Helps set up character hairstyles, animal fur, procedural grooms, and game hair cards. CX Codex +1 907installs procedural-modeling https://github.com/arjun988 The procedural-modeling skill for Claude Code manages procedural 3D asset generation in Blender via MCP. It configures Geometry Nodes setups for rocks, buildings, roads, and cables, preparing meshes for game export. CX Codex +1 622installs geometry-nodes https://github.com/arjun988 geometry-nodes — a skill for Claude Code and other platforms that automates procedural system creation in Blender. It enables asset generation and instancing pipelines via MCP. CX Codex +1 640installs

From the same set5

Project sponsors

Companies that keep this analytics open