The plotter doesn't hide anything
On procedural transparency as an alternative to visualization design
There’s a phrase circulating in institutional discourse right now that I keep running into. “Opacity is the core problem of contemporary AI systems.” ZKM says it. E-flux criticism says it in different words. The proposed solution is always the same: visualization. Design. Make the internal process perceptible. Position the interface as an epistemic mediator between the algorithm and the viewer.
This is a reasonable response to a real problem. Language models, diffusion pipelines, and inference systems are genuinely hard to see inside. They generate outputs whose paths are non-recoverable. They model dynamics rather than capture them — as e-flux criticism noted recently, the photographic regime is an inadequate metaphor for what machine learning actually does to images. A photograph preserves a moment. A model compresses patterns into weights and recreates them. The outputs look like images but they aren’t images in any prior sense of the word.
I agree with all of this. But I think the visualization response assumes something it shouldn’t.
It assumes that if you design transparency well enough, opacity goes away. Build the right interface, choose the right colors, structure the right labels — and the black box becomes a glass box. The curator becomes an educator. The design studio earns its institutional brief.
The problem is that this approach requires a layer on top. You take the opaque system and you add something that makes it legible. But the legibility exists in the added layer, not in the system itself. Remove the visualization and the opacity returns. The visualization is a translation. And like all translations, it has a relationship to power — who commissions it, what it’s designed to show, what it leaves out.
My practice does something different. Not because I planned it that way. Because the machine is structured that way.
The plotter executes instructions. Not inferences. Not compressions. Not statistical associations drawn from training data. It moves a pen from coordinate A to coordinate B. It deposits ink. If you want to know why a line appeared where it did, you read the procedure. It’s there. Nothing is hidden — not by design, not by architecture — by constraint. The procedure is the output. The record and the production are the same thing.
This isn’t a virtue. It’s a consequence of using a machine that was designed for precision drafting, not for generative surprise. But that consequence matters right now. In a moment when the entire discourse around systems art is organized around the question of how to make the invisible legible, plotter-based work offers a different starting point: a system that was never invisible in the first place.
The CMYK layer logic extends this. Each color is a separate pass. Yellow goes down, then magenta, then cyan, then black. The overlap is deliberate, arithmetically determined, visually compound. The image builds in layers that remain distinguishable in the material record. You can look at the paper and trace the procedure. Not through a visualization layer. Through the paper itself.
I’m not interested in making opaque systems transparent through design. I’m interested in working with systems whose opacity is structurally limited by material constraint. These aren’t the same thing. One is a communicative gesture. The other is an epistemic condition.
The distinction matters because it changes what the work can claim. A visualization of a neural network tells you what someone wants you to understand about that network. A plotter trace tells you what happened — because it is what happened. The trace is the execution. There’s no gap between the process and its record.
This is where plotter-based practice sits in the current discourse — not adjacent to AI art, not opposed to it, but occupying a different ontological position. The AI image is a model output. The plotter drawing is a procedural inscription. Both involve algorithms. But one hides the procedure in weights and the other makes the procedure visible through constraint.
The institutions want to solve opacity through design. I find that approach unconvincing. Not because it’s wrong, but because it adds a layer that didn’t need to be there. The legibility was available all along. It just required a different machine.