Preserving the Wobble: Why I Fight My Own Code to Keep Lines Imperfect

I own a pen plotter. It’s a little robot arm that holds an actual pen and draws on actual paper, and it has taught me more about software defaults than any code review. Because here is the dirty secret of vector-to-plotter pipelines: at every single stage, the software is quietly trying to erase the thing I care about most. The wobble. The hand. The evidence that a person made a mark.

Let me walk through where it tries.

Stage one: the scan or trace

I draw something on paper, then digitize it. Auto-trace tools — the ones that turn a bitmap into vectors — have a parameter usually called “smoothing” or “corner threshold,” and its entire purpose is to throw away the small deviations that make a line look human. Crank it up and your shaky ink becomes a serene Bézier curve that looks like it came from a logo template. Turn it off and you get ten thousand jagged points that plot slowly and chew through pen tips. The “correct” setting, the one the tool nudges you toward, is the one that makes your drawing look like it was never drawn. I keep it low and pay for it in point count, on purpose.

Stage two: path simplification

Now I have an SVG. The next instinct — mine included, the first time — is to run it through a simplifier like the Ramer–Douglas–Peucker algorithm to reduce the point count so the plotter runs faster. RDP works by asking, of each point, “if I deleted you, how far would the line move?” and dropping any point that doesn’t move it more than some epsilon. That’s a beautiful algorithm and it is precisely a wobble-removal machine. The wobble is, definitionally, a bunch of points that don’t move the line very far. Simplification targets exactly the signal I’m trying to keep.

So I had to split the idea in two. There’s redundant detail (collinear points, sampling noise from the digitizer — fine to remove) and there’s expressive detail (the tremor of my hand, the over-shoot at the end of a confident stroke — must keep). RDP can’t tell them apart because it only measures geometric deviation, not intent. My compromise was a frequency-aware pass: remove points whose deviation is below the noise floor of the digitizer, but never below the noise floor of the hand. In practice I measured both — drew a slow careful line and a fast loose one, looked at the deviation distributions, and set epsilon below where my hand’s variance lived. It’s a hack. It works. The plots still wobble.

Stage three: normalization

This is the sneakiest one. Somewhere in any real pipeline you normalize coordinates — scale to fit the page, center the drawing, maybe snap to a grid for registration. Snapping is poison. The instant you round endpoints to a grid, parallel hand-drawn lines that were charmingly almost parallel become rigidly, mechanically parallel, and the whole thing dies. I removed every snap. I scale and translate with full floating-point precision and accept that nothing lines up perfectly, because nothing lined up perfectly on the paper either. That’s the point.

Stage four: the plot itself

Even the physical plot fights me, but here it fights for me. A pen plotter introduces its own wobble — backlash in the belts, ink pooling at direction changes, the pen skipping on rough paper. For a long time I treated these as defects to tune out. Then I realized I had two layers of imperfection stacking: my hand’s wobble plus the machine’s wobble, and the combination is more alive than either alone. So now I tune the machine for reliability (it shouldn’t skip a line entirely) but not for sterility (a little ink pooling at corners is a feature). The plotter is a collaborator with its own handwriting, and I stopped trying to make it write like a laser printer.

Why any of this matters

You could read all of the above as one cranky artist refusing to let computers help. It isn’t. It’s a specific engineering claim: the defaults of a toolchain encode a value system, and that value system is usually “make it look manufactured.” Smoothing, simplification, snapping, anti-aliasing, auto-correct — every one of these is a small machine for removing evidence of a person. Most of the time that’s what you want; manufactured is clean and clean is professional. But when the entire point of the artifact is that a human made it, every helpful default becomes an adversary, and you have to go through your pipeline stage by stage and disable the help.

The travel-optimization part of my toolchain — sorting the order in which the pen draws strokes to minimize wasted movement — is the one place I let the computer be ruthlessly optimal, because that’s about time, not line quality. The pen lifts and moves invisibly; nobody sees the travel. That distinction became my rule: optimize what the viewer can’t see, protect what they can. Speed, ordering, file size — optimize freely. The actual deposited mark — never touch it.

I think this generalizes beyond plotters. Any time you’re building something whose value is that it feels human, your job is partly to identify every place your tools want to sand off the humanity, and to stand in the way. The wobble isn’t an error to be corrected. The wobble is the work.