Wrought ·  Friction ·  Annotated

Direction as
Argument.

Taste scales.

usm haller
Fritz Haller

Most design consulting commits to a singular domain. Direction commits to the question.

revealed.design separates signal from noise.

Interior · product · editorial · image · web.

The substrate changes. The signal holds.

Wrought, friction, annotated isn't a checklist—it's the filter.

The filter is the studio.

scroll down
The Practice

Question, workbench, defense.

The modes the work passes through. All pieces start at the question, some are still on the workbench; all get critiqued by the panel, only a few pass.

The argument must hold.

Question

Where the work begins. How does a chromogram work? Best metal finish for a wax embosser? What's the right easing for a particle dissolve? A curiosity that won't sit still, and the patience to follow it past the answer that comes too fast.

Workbench

Where the work is forged. Steven directs; SAL900X codes — an AI collaborator, present at every iteration. Every line is annotated. Every decision flagged. The source is the documentation. The full method is compiled in a working paper (Hermitic Praxis…; forthcoming). Most of it never ships. The workbench doesn't hurry.

Defense

Where the work proves its mettle. The piece goes to a simulated panel review — multi-disciplinary analysts, the questions an honest critic would ask: the cross-examination the studio runs on every claim. If the central argument breaks, the piece doesn't ship.

The Offer

What you hire is the method.

Not the deliverable. Direction across substrate; the method scales; the work follows.

Call it dialectic: you bring the question, the studio brings the friction, the work is what holds.

// /method · the proof step
// build  —  2026-05-01T22:47:32 MST

const manifest = document.querySelector('.manifest-terminal');
const cursor = manifest.querySelector('.manifest-cursor');

// the frame
manifest.style.border = '1px solid var(--cream)';
//  —  too pure on graphite
manifest.style.border = '1px solid var(--flame)';
// hairline, not a stroke
manifest.style.borderRadius = '24px';
//  —  too pillowy; tighten
manifest.style.borderRadius = '2px';
// 2 holds the rectangle
manifest.style.padding = '24px 32px';
//  —  24 felt cramped
manifest.style.padding = '28px 32px';
manifest.style.background = 'rgba(0,0,0,0.18)';

// the cursor  —  sal voice at minimum resolution
cursor.textContent = '>';
cursor.style.color = 'var(--flame)';
//  —  flame is rare and transient; bitossi is default (per 126c)
cursor.style.color = 'var(--bitossi)';
cursor.style.transition = 'color 140ms cubic-bezier(0.23, 1, 0.32, 1)';
//  —  the kare-ization of the sal voice

// the mask — older lines fade into the dark
// TODO: tune mask offset
//  —  ok, the gradient handles it
manifest.style.maskImage =
  'linear-gradient(to bottom, transparent 0, black 60px)';

// every flourish earns its place
cursor.style.animation = 'sal-cursor-blink 530ms step-end infinite';
//  —  fifty years of terminal grammar; inherit it

// the runner — sentinel light along the perimeter
const runner = { angle: 0, period: 1600, start: performance.now() };
function spin(now) {
  const t = (now - runner.start) % runner.period;
  runner.angle = (t / runner.period) * 360;
  manifest.style.setProperty('--runner-angle', runner.angle + 'deg');
  requestAnimationFrame(spin);
}
requestAnimationFrame(spin);
//  —  the runner traces the perimeter once per cycle

// ignition  —  2026-05-01T22:48:01 MST

// the recurse  —  the function returns its own source.
// (a quine via Function.prototype.toString. the studio
//  takes the shortcut and gains the elegance.)
manifest.recurse = function recurse() {
  return recurse.toString();
};

// proof:
console.log(manifest.recurse());
//  → function recurse() { return recurse.toString(); }
//  output equals input, byte-identical.
//  the artifact proves the method.

manifest.iterate = manifest.recurse;
//  —  iterate IS recurse, named for the moment.

// — the manifesto —
// 1. every flourish earns its place.
// 2. the work is what holds.
// 3. direction across substrate; the method scales.
// 4. the artifact proves the method.

//  —  iteration  —

manifest.recurse();
//  → function recurse() { return recurse.toString(); }
manifest.recurse();
//  → function recurse() { return recurse.toString(); }
manifest.recurse();
//  → byte-identical, every time.

// the artifact proves the method. the build log holds.

Bring the question.

(Be the dialectic.)