Nero Carrara Chevron Inlay Material
Project Overview
A seamless 4K marble floor material — black Nero Marquina with a Carrara chevron inlay — built as a conversation between me and an AI collaborator. The Substance 3D Designer graph wasn’t hand-authored. It was written by Claude as a Python script, run inside Designer’s Python Editor. My job moved up a level: supply the reference, render in Marmoset Toolbag 5, mark up the screenshot with what felt wrong, write a note on the desired look. Claude’s job: measure, model, bake, re-generate.
Every node, link, and parameter in the graph comes from that script, so the material is reproducible from source. Change one named constant at the top of the file and the entire set re-bakes end to end. The case study below documents the loop: what was analysed, what was computed, what was generated, and what I decided.
Role & Responsibilities
Art director. I chose the material and the reference, set the bar for pattern fidelity, rendered every iteration in Marmoset, marked up what felt wrong on the screenshot, and made every call on what the final material should be. Claude wrote and re-wrote the Designer Python script, baked the geometry, and tracked artefacts down to their cause.
This case study is a pipeline demo first and a material second. The piece proves what I can get out of an AI collaborator when I keep the design decisions in my hands and let the model handle measurement, modelling, and reproducibility.
Key Contributions
- Chose the material, the reference, and the bar for pattern fidelity — whole floor as one tile, exact stripe layout, exact joint behaviour
- Rendered every iteration in Marmoset Toolbag 5 and reviewed each pass against the reference by hand
- Marked up renders with red arrows and a sentence on what felt wrong — “the black isn’t black enough”, “the centre joint shouldn’t run through the diamond”, “more scuffed white veins on the Nero”
- Decided which reference wins when two disagreed (black grout, not grey)
- Directed Claude through roughly twenty iterations to the final look
- Owns the Designer session, the ~1,200-line Python source, the package, and the final renders
The Loop
Designer was never driven by hand. Every node, link, and parameter comes from a Python script run in Designer’s Python Editor, so the material is reproducible from source. I supply the reference, render in Marmoset, mark up what’s wrong, and decide what it should be. Claude measures, models, bakes, generates, and diagnoses.
Who Did What
Me
- Chose the material and the reference
- Set the bar for pattern fidelity — whole floor as one tile, exact stripe layout, exact joint behaviour
- Rendered every iteration in Marmoset Toolbag 5
- Marked up screenshots with red arrows and a sentence on what felt wrong
- Decided which reference wins when two disagreed (black grout, not grey)
- Owned the Designer session, the final renders, and the package
Claude
- Rectified the reference photo; ran a structure tensor to map stripe directions — exposing a 4×4 grid cut diagonally into alternating striped triangles
- Reduced the pattern to a handful of rules so a one-number change re-bakes the whole set
- Baked the geometry outside Designer (seven 4K maps from one signed-distance field) so the tile wraps on both axes by construction
- Replaced Designer’s Perlin Noise with frequency-domain baked fields — no lattice artefacts in the veins
- Wrote the ~1,200-line Designer Python script; ~230 nodes in 13 framed sections, every tunable knob a named constant at the top
- Diagnosed artefacts at root cause — a high-pass on the base colour revealed faint lines were ghost joints being displaced per stone; reordering two nodes fixed it
Reading the Reference
The reference was an oblique product photo — a chevron floor shot from standing height, foreshortened down the back of the image. Claude, talking to Designer, couldn’t get the pattern from it. The first attempts came back wrong twice in a row: a pinwheel of L-shapes, then concentric diamonds. Both read as plausible from the photo at that angle; neither was what the floor actually was.
The unlock wasn’t a better prompt. It was changing what Claude was looking at. I had it rectify the photo into a square first — killing the perspective, flattening every tile to the same scale — and only then analyse what was in frame.
Writing the Graph
The material is a roughly 1,200-line Python script using Designer’s sd API. Run on an active graph, it wipes every non-output node and rebuilds: ~230 nodes in 13 framed sections, each a self-contained stage with a comment header. Knobs live at the top of the file as plain named constants, so a review note like “black not black enough” is a one-line edit followed by a re-run.
Graph sections, in build order: Main Pattern · Per-Tile Data · Veins · Grout Halo · Grime & Dust · Cream Marble · Dark Marble · Cracks · Edge Wear · Height & Normal · Roughness · Base Color · Outputs.
Render, Mark Up, Diagnose
I drove every iteration from renders. Red arrows on a screenshot, a sentence on what felt wrong. Some notes were direct (“the black isn’t black enough”, “the centre joint shouldn’t run through the diamond”). Others needed forensics: faint straight lines survived two noise rewrites. A high-pass filter over the base-colour export revealed they were ghost copies of the joints — traced back to a stain mask that already contained the joint halo being displaced per stone by a directional warp. Reordering two nodes fixed it.
Detail Gallery



