The Longest Way to the End, Repaint and Algorithmic Build and Redux

This documents a piece I made in collaboration with Claude — a generative algorithm built from two oil paintings and the relationship between them.

The Two Paintings

The first painting is finished. The Longest Way to the End is about the moment a relationship ends — not the slow unraveling, but the specific reality of it. The composition is organized around a single vortex: a moon in the upper right that pulls everything toward it, red diagonals crashing inward, a navy weight anchoring the left edge. There is no horizon. The whole canvas is an event.

The second painting is part of my ongoing Hours Ago series, where titles mark the duration since a life-changing event without naming what the event was. This canvas is about 30% finished. The palette has moved away from red into pinks, magentas, and deep teals. The diagonals are still there, but they’re not crashing — they’re dispersing and I don’t know if they’ll be on the final painting. There’s no single compositional eye yet. The painting is still figuring out what it is.

The Question

I brought both paintings into Claude and asked: if the red painting is the rupture, what’s the logical endpoint of the pink one? What does the algorithm look like if it treats these two canvases as a journey — origin and destination — and finds its own way between them?

What would be the logical endpoint for the pink painting if it’s the opposite or final destination of the red painting in a journey? I’d like something algorithmically based that flows through options for endpoints and back through the finished painting or pieces of it, with depth and complexity that matches oil painting.

I didn’t know what the endpoint was, not that Claude would know either. That uncertainty was the assignment.

What Claude Worked Out

Before writing any code, Claude proposed a framework for the journey itself. The answer it arrived at was this: the red painting has one eye. Everything in it is organized around an obsessive center — the moon, the wound, the vortex. The pink painting’s endpoint, understood as the opposite of that, isn’t healing. It’s the loss of center. What returns isn’t wholeness — what returns is sky. A horizon that the rupture tore open, finally reassembling somewhere further out, cooler, without a moon needing to arbitrate.

(I’m guessing I’m going to have a moon in the final, I’ve been obsessed along with everyone else.)

It named four candidate endpoints for the algorithm to explore on the way there:

Dissolved — near-monochrome, almost all color memory gone.
Mirrored — the red painting’s composition held in cool temperatures, inverted.
Submerged — the red painting seen through deep water, its palette filtered through blue.
Horizon — the true destination: pink sky meeting teal water, no moon, no vortex, no event. Just weather.

The journey structure runs: Rupture → First Hours → Dispersing (the current state of the pink canvas) → Exploration of the four endpoints → Settlement at Horizon → Memory Returns → loop. Memory Returns is the part I found most true — fragments of the red painting briefly reassert themselves before the cycle begins again. A moon apparition. A diagonal. A field of red. Then they dissolve back into the pink.

Building It — The Iterations

The first version had a sidebar with controls: tempo, memory return, paint density, seed navigation, and buttons to lock the piece into any of the four endpoint states. Useful for understanding the algorithm, but not what the work should be.

I asked for the next version without controls — a standalone piece that never ends. Claude replaced the looping time variable with three incommensurate sine waves, which means the piece walks through the journey space continuously without ever exactly repeating. Instead of clearing the canvas on loop, old layers are periodically softened with translucent glaze passes so marks sink into the ground rather than disappearing — a palimpsest effect that felt right for work about elapsed time.

The feedback I gave from there was specific to the painting:

The green color and the hard lines read very differently from the paintings. The color is off, and the marks are more ribbon-like in the original than what the algorithm is producing. I’m not loving the greens.

The greens were a real problem. They’d been pulled from a small acidic passage in the lower-left of the red canvas and overweighted in the palette mapping. Removing them and pushing those palette slots toward warm oranges and coral pinks brought the color back toward the actual paintings. The ribbon marks were a separate issue — the algorithm was stepping ellipses along a path, which produces lumpy, stippled edges. The actual structural dark lines in both canvases are continuous: one long pull of a loaded brush, width varying along it. Claude rebuilt these as triangle-strip geometry — single unbroken shapes with an internal spine — which finally read correctly.

The last round of feedback was about the brushwork generally:

This squares the strokes off a little strangely. I have thicker and thinner paint strokes intermingling.

Looking at the paintings closely, the issue was that the algorithm had one brush width range and distributed marks uniformly. My actual paintings layer large flat-brush drags with narrower strokes weaving through them and thin calligraphic lines overlaying both — all in the same region, not in separate zones. The fix was four named brush categories (slab, standard, liner, fine) that all compete for placement in the same compositional area, with width ranges from 20–44px down to 1.2–2.8px. Strokes also got asymmetric taper — loaded and full at the start, dragged thin at the end — which is how a brush actually moves. And each stroke now commits to a direction based on its initial flow angle rather than chasing the vector field at every step, which eliminated the snake-like drift that made marks feel indecisive.

What the Piece Does

The final piece is a fullscreen generative painting that runs without stopping and without a reset. It generates marks in six layered buffers — an imprimatura wash charged with the red painting’s palette, then underpainting, gestural mid layer, sharper top layer, structural ribbon marks, and a memory layer that flashes fragments of the red painting and slowly fades. Every 20–40 seconds a soft glaze pass runs; every 70–150 seconds a heavier tonal shift moves the base toward wherever the journey currently is. Old marks don’t disappear — they sink.

The piece drifts through its journey space on a non-repeating time signal. It visits Rupture. It passes through where the pink canvas currently lives. It explores each candidate endpoint in sequence, settles at Horizon, and then — before the cycle continues — the wound shows up again briefly, the way it does.

Each load generates from a different random seed. Every run is the same piece and a different painting.

On Using Claude for Studio Work

I’ve written before about using LLMs as a thinking tool in my practice. This project is a good example of what that actually looks like in operation. I brought two paintings and a conceptual question. The algorithm’s structure — the four endpoints, the palimpsest glaze logic, the memory-return phase — came out of a back-and-forth in which I was genuinely asking rather than directing. The color and mark corrections came from me studying my own paintings and translating what I saw into language specific enough to act on.

That translation is the work. Knowing that greens were wrong, and knowing why — knowing that my marks are ribbon-like and that ribbon-like means continuous geometry rather than stepped ellipses — required looking at the paintings carefully enough to understand them technically, not just visually. The AI collaboration made that necessary.