A Victorian product page that sells Frankenstein's creature like a flagship device, built end-to-end in Rive's GPU canvas by a team of coding agents that were never allowed to look at a single render. This is my own entry to the Rive Halloween Challenge, built in the open as a proof of how I run AI-assisted production. It is not client work. #rivehaloweenchallenge

The Rive Halloween Challenge asks for something spooky built with the Rive CLI and GPU Canvas, with bonus points for finishing it by hand in the Editor. I wanted a piece that would be judged on the full rubric at once: a creative concept, heavy use of CLI and GPU Canvas, real interaction, polish, and a visible human touch.

The concept was a product launch page for a man built from parts. Donor-sourced anatomy, hand-sutured seams, galvanic power-on, and a configurator that lets you build your own creature and throw the switch.

The problem was scale. The anatomy underneath him is BodyParts3D, a research-grade model of more than two thousand separate meshes. It does not fit in Blender on a mac mini base model. And the deadline was days, not weeks.

Instead of shrinking the body, I moved the lab. One agent wired Blender into Google Colab, headless on a cloud GPU, bootstrapped entirely from scripts it wrote. I never opened Blender.

From there the build ran as a small team of agents with one human at the bench:

An orchestrator that runs the project and routes my feedback to the right lane.

A bake agent that owns the cloud: segmenting the anatomy into skin, muscle, organs and skeleton, grafting the creature's head, rigging, lighting and baking every story beat.

A runtime agent that owns Rive: pulling each bake down and building it into one living .riv with hand-written WGSL shaders, scripted interactions and a data-bound configurator.

The rule that made it work: none of the agents may look at a render. They prove their work with measurements instead. Twenty thousand rays cast through the head per pose to show the skull sits inside the face. Pixel probes on the skin for color and contrast. Thousands of hit probes against the UI. Every verdict I gave became a measurement, and every measurement became a gate the build has to pass before anything ships.

I am the only pair of eyes in the loop. I watch previews, say what is wrong, and the fix comes back with numbers.

The scroll story. A prologue in a dark Ingolstadt lab, then eight story beats: hero, pan, overhead, schedule of parts, the lightning strike, reveal, craft and handoff. Thirteen delivered render sequences are mapped into those eight beats and embedded in the file. Copy sits on a tinted scrim with a contrast gate, so every text beat passes 4.5:1 against the frames behind it.

The five-stage configurator. Donor selection per limb, a charge wand you paint with, a vitrification glaze brush, four atomizer finishes (verdigris, porcelain, acid iridescent, charnel bronze), then suture and galvanize, with a full skeletal x-ray at the moment of discharge and a checkout screen at the end. All of it is scripted and data-bound inside Rive.

The shaders. Charge painting, vitrification, the four material finishes and the x-ray surge are hand-written WGSL running on the GPU canvas. Fog rolls in behind the body, distance-graded, with a rule that not one pixel of it may drift in front of him.

The calibration loop. The body was measured at exactly 1.719 m in every scene, so when he looked small on the operating bed the agents found the bed had been stretched 40% and never put back. The fix went into the bed, with a permanent rule that the body must span 88 to 96% of the mattress. Sutures that read white were recoloured deep dried-blood red in the baked film and the live shader in the same hour. The skin took a 14 degree shift toward green, with numeric redness floors and hue-separation minimums so he cannot quietly get healthy again.

The human pass. The whole build pushes to Rive as one file, with the editable layer kept Rive-native: titles, controls, overlays and pacing are ordinary named Rive objects, so I finish the artwork, seams and diagrams by hand in the Editor.

This is my own work, so there is no client number to report. What I can show is observable scale and what it proves about the method.

One shippable .riv of roughly 25 MB holding 604 embedded frames and more than 25,000 objects, built and verified without a human opening Blender.

A verification suite of several hundred automated checks across story, scene contract, interaction, contrast and anatomy gates, all green before every push.

Every operator verdict converted into a measured, permanent gate rather than a one-off fix.

The method is the product. A frontier model orchestrating, specialised agents doing the heavy work, and a human at the bench with the only eyes in the room. That is the same discipline I bring to client builds.

Built for the Rive Halloween Challenge. Tools: Rive CLI, Rive GPU Canvas, WGSL, Blender, Google Colab, Claude Code agents.

@rive_app #rivehalloweenchallenge