Ninefold is a streetwear brand that doesn't exist. Every model, every outfit and every product photo on it was generated with Higgsfield, from Claude Code, through the Higgsfield MCP and CLI. You can shop the drop at avivashishta.com/lab/look-deck. Nothing is for sale, but the bag works.
It sits on the same stage as my Deal hero: a deck dealt into a fan that lifts into a turning wheel. Here the cards are twelve looks, the wheel is drawn in WebGL so it blurs when it spins fast, and it rises from behind a rooftop at golden hour. Hover a card and its three pieces pop out beside your cursor. Click it and the card flies out into a stack you can swipe, with a dot on every piece and a panel that shows that piece's product photo large.
The short version: generate one look per card in one studio with one light, then make every product photo from its look (the look is the reference image), so the jacket in the panel is the jacket on the model. Draw the deck in WebGL but keep invisible HTML cards on top for links, focus and hover. And let the wheel behind the open look keep turning to it, so closing can fly the card straight back into its slot.
The prompt
Paste this into Claude Code with the Higgsfield MCP connected (or the Higgsfield CLI installed). It describes the behaviour and the asset pipeline, not my file layout, so it works in any React project.
Build a one-screen shop-the-look site for a made-up Gen Z streetwear brand. Generate every image with Higgsfield. React, Motion (framer-motion), three.js for the deck. Show me the cost of each Higgsfield batch before you spend credits.
THE LOOKS (Higgsfield, GPT Image 2.6, 3:4, high quality, 2K): twelve full-body looks, one model each, all in the SAME warm off-white seamless studio with the SAME soft window light from the left and a gentle floor shadow, shot like a 50mm editorial. Vary the models and the outfits (three pieces each: a top layer, a bottom, shoes), never the set or the light. End every prompt with: no text, no logos, no branding, no graphics anywhere. After each batch, look at the shoes and chests closely and regenerate anything with a brand mark.
THE PRODUCT PHOTOS (one per piece, 36 in total, GPT Image 2.6, 1:1, medium, 1K): pass the look image as the reference and ask for ONLY that garment, the exact same color, wash, fading, texture, seams and proportions, laid flat from above (shoes as a pair at three quarters) on a warm off-white background with a soft shadow. Because every product photo is made from its look, the panel always matches the model.
THE WORLD: one wide photo of a city rooftop at golden hour with a big sky. Use it twice: as the background, and as a cut-out of only its parapet and roof gear (a hand-traced polygon mask, feathered 1px) drawn in front of the deck at the same size and the same parallax depth, so the cut lines up and the wheel rises from behind the roof's edge. Pin the photo's bottom edge to the hero frame's bottom edge.
THE DECK: 34 cards on a full circle around a pivot below the hero, only the top third visible, cycling the twelve looks. Each card face is a 9:16 crop of its look, with the look's total price in a pill. A loader deals the cards face down from below and flips them up into a fan, then lifts the fan into a slowly turning wheel. Drag, wheel and swipe turn it.
WEBGL: draw the card faces with three.js on one canvas the size of the viewport (not the frame, or cards get cut off during the full-screen intro). Build each card's matrix from the same numbers as a CSS transform and convert with F * M * F where F flips Y, with a perspective camera whose fov makes 1 unit = 1px at z = 0 (fov = 2 * atan(height / 2 / 1400)) and a view offset that puts the vanishing point on the hero's centre. Recompute that offset every frame from layout values (offsetLeft, clientWidth), not from getBoundingClientRect. The only effect: blur each face along its direction of travel in the fragment shader, scaled by how fast the wheel is turning, zero below the idle drift, so a resting card is sharp. Keep the real HTML cards on top with their pictures at opacity 0: they are the links, the focus targets and the hover frames, and if WebGL fails they simply show.
HOVER: hovering a card fans its three product photos out beside the cursor like a hand of cards (about 130px each, rotated -9, 0 and 9 degrees, a bouncy staggered spring), each with the piece name and price. The fan follows the cursor on a tight spring and leans into the direction of movement.
OPEN A LOOK: clicking a card flies it out of the wheel into a large portrait (FLIP from the card's box; the card shows a 9:16 slice of the 3:4 look, so open the slice with a clip from the sides as it flies). The next two looks peek out behind it as a stack. Drag the top card sideways and let go past 110px (or flick faster than 500px/s) to throw it off and bring the next one forward; arrow keys, buttons and two-finger trackpad swipes do the same. Every swipe also turns the wheel behind so the open look sits at the top slot, and closing flies the card back into that slot while the wheel sharpens.
THE PANEL: one piece is always open with its product photo large; the other two are slim rows. Hovering a dot on the model, or a row, opens that piece (animate the layout with a spring). Each piece has a name, a one-line note, a price, size buttons and Add to bag. Add the full look sits at the bottom in the look's color. Adding flies the photo into the bag button, whose count bumps. The bag is a drawer with quantities and a subtotal; checkout says it is a demo.
SPEED: after the intro, fetch and decode every look and product photo a few at a time with requestIdleCallback and a timeout (the wheel animates every frame, so the browser is rarely idle without one). One requestAnimationFrame loop for the deck, writing a style only when it changed.
Start with the asset plan and its credit cost, then the deck, then the look view, then the bag.
Concept 1: AI slop comes from inconsistency, so fix the set
The first test looks I made were fine on their own. Put twelve of them in a row from twelve prompts and it looks like twelve different shoots, which is the thing that reads as AI. A real lookbook is one studio, one light, one lens on one day.
So the prompt is a template and only two slots change: the model and the outfit.
Full-body editorial streetwear photograph, Gen Z model standing in a seamless warm
off-white photo studio, soft natural window light from the left casting a soft window
shape on the wall, gentle floor shadow. {model}. Outfit: {outfit}. {pose}. Shot on 50mm,
f/5.6, whole figure from head to shoes with space above and below, natural skin texture,
real fabric weight and creases, believable proportions, subtle film grain.
No text, no logos, no branding, no graphics anywhere.
The window shape on the wall ended up being the detail that sells it. It's in every photo, in roughly the same place, so the cards read as one set the moment the wheel turns.
Concept 2: the product photo is made from the look
A shop-the-look panel falls apart if the hoodie in the panel isn't the hoodie on the model. Generating products from text gets you a hoodie, not that hoodie.
So every product photo uses the look itself as the reference image and asks for only one garment out of it:
Studio e-commerce product photo of ONLY the washed charcoal zip hoodie with raw hem
worn in the reference photo: the exact same garment with identical color, wash,
fading, fabric texture, seams, hardware and proportions. Laid flat and neatly arranged,
shot from directly above, centered with generous margin, on a seamless warm off-white
background with a soft natural shadow. No person, no body, no other clothing or props,
no text, no logos, no tags.
At medium quality and 1K that's half a credit each, so all 36 cost 18 credits. Shoes get "a pair side by side, three-quarter view" instead of a flat lay, because flat shoes look like a mistake.
Two things I checked by eye on every batch: shoe sides and chests. Image models love to add a swoosh or three stripes. None of these have one, though a couple of the silhouettes are close to famous shoes.
Concept 3: WebGL faces, HTML cards
I wanted the wheel to feel premium when you flick it, like the carousels on HorizonX where cards smear as they move. CSS can't blur along a direction, and CSS blur on 34 cards every frame is slow. A shader can.
But the deck's behaviour (the loader, the deal, the lift, the gestures, links, focus, hover frames) already worked in HTML. So the HTML cards stay. Their pictures go to opacity 0, and a canvas behind them draws the same cards from the same numbers:
// The same pose as the CSS transform, as a matrix.
m.copy(stage)
.multiply(t.makeTranslation(0, pivot, -away * .5))
.multiply(t.makeRotationZ(rad(home * p)))
.multiply(t.makeTranslation(0, ty, 0))
.multiply(t.makeRotationY(rad(flip)))
.multiply(t.makeScale(k, k, k));
// CSS's y axis points down, three's points up.
mesh.matrix.copy(F).multiply(m).multiply(F);
For the two to line up exactly, the camera has to match CSS's perspective: 1400px: a field of view where 1 unit is 1 pixel at depth 0, and a view offset that puts the vanishing point at the hero's centre even though the canvas covers the whole viewport.
camera.fov = THREE.MathUtils.radToDeg(2 * Math.atan(h / 2 / 1400));
camera.setViewOffset(w, h, w / 2 - cx, h / 2 - cy, w, h);
My first version computed cx and cy only on resize. The frame can move without resizing (fonts load, the header settles), and then the hover frame lands next to the card instead of on it. Now it's checked every frame from offsetLeft and clientWidth, which also ignore transforms, so the zoom when a look opens moves canvas and cards together.
The effect itself is one loop in the fragment shader: eleven samples along the card's x axis, spread by the wheel's speed, weighted toward the centre.
float len = abs(uVel) * 0.08;
for (int i = 0; i < 11; i++) {
float t = float(i) / 10.0 - 0.5;
float w = 1.0 - abs(t) * 1.2;
acc += face(clamp(vUv + vec2(t * len, 0.0), 0.0, 1.0)) * w;
total += w;
}
I also tried bending the cards and adding a colored rim and an RGB split. It looked like a demo of effects. Blur alone looks like speed.
Concept 4: a rooftop the wheel rises out of
The homepage's wheel rises out of a painted cloud bank. Here it's a photo, so the front layer is the photo itself: the same rooftop image with everything above the parapet cut away. Both layers are drawn in the same box at the same parallax depth, so the cut never slides off the roof it came from. Then the image is pinned by its bottom edge to the bottom of the hero frame, so the parapet sits right at the frame's foot on any screen.
Concept 5: the wheel keeps turning behind the open look
Closing a look is where most shops cheat with a fade. I wanted the card to go back where it came from. The problem: you might have swiped through five looks since you opened it.
So the wheel follows you. Opening a look, and every swipe after, asks the deck to bring the nearest card of that look to the top slot, and the wheel turns there behind the blurred backdrop:
focus: slots => {
const kick = -28 * expansion.get();
let best = slots[0], delta = Infinity;
for (const slot of slots) {
const d = wrap(slot * step + kick - target);
if (Math.abs(d) < Math.abs(delta)) { delta = d; best = slot; }
}
velocity = 0; target += delta;
return best;
},
When you close, the right card is already waiting at the top, and the portrait flies into its box. Because the card shows a 9:16 slice of a 3:4 photo, the flight also closes a clip from the sides, so the portrait turns into the card instead of shrinking into it.
Concept 6: one piece open at a time
Three equal rows of product photos make every photo small. Now one piece is always open with its photo large, and the other two are slim rows. Hovering a dot on the model opens that piece, and so does hovering its row. It reads as pointing at the jeans and seeing the jeans.
Motion's layout prop does the resize with a spring, so the grid changes from a row to a stacked card without a jump.
Concept 7: load everything before anyone asks
The deck's card faces load during the intro. The look photos and product photos used to load on demand, so the first hover fan and the first open look showed blank boxes for a moment. Now, once the intro has played, every one is fetched and decoded four at a time:
const idle = (fn: () => void) =>
"requestIdleCallback" in window ? window.requestIdleCallback(fn, { timeout: 400 }) : setTimeout(fn, 120);
The timeout matters. The wheel animates every frame, so the browser is almost never idle, and without it the preloading simply never ran.
What it cost
About 54 Higgsfield credits of images: 12 looks at 2.75 each, 36 product photos at 0.5 each and the rooftop at 2.75. I also spent 40 credits testing two looping video clips for the cards, then dropped video entirely. The stills were better, and a wheel of 34 videos is a lot of decoding for a hero.