Why we build props with code

Most of the assets in our first pack are not modelled by hand in the usual sense. They are a few hundred lines of Blender Python each — parameters in, mesh out.

That surprises people, and it surprised us. Here is why it happened, and what it costs.

The audit forced it

The short version is in inspected from where: when we finally rendered every asset from five angles instead of one, the failures clustered. Woven surfaces, thin plates with real thickness, repeating parts, precise joinery. All of them shape problems, none of them random.

Those are exactly the shapes code is good at. A slat exists because a loop put it there. Shelf spacing is equal because it was computed rather than eyeballed. A mitre closes because it was constructed. Nine books on a shelf are nine separate books with nine different heights, because a list said so.

Seven pieces the gate had rejected were rebuilt this way. All seven passed.

The part nobody talks about: what a small correction costs

This is the argument that actually convinced us, and it has nothing to do with quality.

Suppose the drawer spacing on a desk is slightly off.

If the desk is a one-off object, fixing it means going back into the object and moving things, and if the fix is at all structural you may end up with a different desk — a slightly different leg taper, a slightly different edge radius — that no longer matches the credenza you already approved. Now you either accept a set that does not match itself or you go and touch the credenza too.

If the desk is a script, you change a number. It is the same desk with correct drawers. Then, because the finishing stage runs in about a second per asset, you re-run the entire set for free and everything downstream is consistent again.

On a set of twenty-seven pieces where consistency is the product, the ability to make a small correction without disturbing the design is worth more than any single asset’s fidelity.

Free iteration changes what you attempt

When a candidate costs nothing you try the harder thing.

Our corner shelf has genuinely equidistant fan-shaped shelf boards and true right angles at the wall, because getting there was thirty runs of a script and thirty runs cost nothing. Under any budget where each attempt is expensive, thirty attempts at a corner shelf is not a decision anybody makes — you take the third one and move on.

Same for the bookcase with forty-two individually placed books, the book row with one volume leaning, and the slatted waste bin. All cheap in triangles and all annoying to do once by hand, let alone thirty times.

What code costs you, honestly

This is not a piece arguing that everything should be parametric.

Code produces clean and simple. Our book stack has no cover detail. The waste bin is a slatted cylinder rather than real weave. Those are legitimate low-poly idiom — the stylized vocabulary accepts them — but they are a step down in richness from a surface someone laboured over.

Code is slower to write than to model, once. A parametric bookcase is a couple of hours. Modelling one bookcase is faster. If we needed one bookcase rather than a coherent family of twenty-seven, this would be the wrong choice outright.

Code has no taste. A script builds exactly what it was told to build and has no opinion about whether the leg taper is right. The design has to come from somewhere else, and the judgement of whether it worked has to come from a person looking at it.

Which is the actual division of labour here: the reference decides what the set looks like, code constructs what code is good at constructing, deterministic tooling finishes everything the same way, and a person with a veto looks at all five sides before anything ships.