Huntley’s Loom Changed How I Think About Control

TL;DR — Two years of AI-assisted software building turned me from the author of my code into its approver. My first approach was verification: prove the output is ready before it ships. Necessary, but half an answer — it guards the exit, not the work. The other half governs the boundaries the AI works inside. Geoffrey Huntley's Loom convinced me the answer isn't less AI in the loop — it's embracing the fact that AI should be fully inside the making. But AI fully inside only works if the boundaries hold, because drift is what happens the moment no human hand is on the building. We can let AI work inside the boundaries without limit while at the same time proving deterministically that it stays there. Not slower. Not less AI. Just in control.

I've been uneasy about AI for two years. Not because the models are bad — they're extraordinary. Not even because of the slop produced; that plausible, confident, subtly wrong output. It was something harder to name. It was only when I stopped letting the code scroll by that I realized what I had been struggling with.

I'd been accepting the AI's walls of text the way everyone did — skim, nod, move on. Then, in a moment, I stopped and actually read the code. Line by line. And it dawned on me that I had no idea what most of it did. I hadn't written it. I hadn't chosen it. I'd just been approving it.

Somewhere in there I had lost the craft of building software — not the output of it, the command of it. The feeling cut deep.

My unease was never about quality. It was about agency. Author to approver, the maker to a checkpoint the work passed through. The worst part was that under AI, “approver” had been my role from the very first line. I never directed the pattern. I just signed off on it.

Under AI, “approver” had been my role from the very first line. I never directed the pattern. I just signed off on it.

There's a world of difference between a human in the loop and a human in control of AI.

In the loop, you're a station on an assembly line run by automation. Work flows to you, you rubberstamp it, it flows on. The code arrives faster than you can read it, in a form you didn't choose, at a scale that dares you to say no. Often, the output isn't even what you asked for. Instead, it’s just a more impressive-looking version of something adjacent to it.

The trap is that it feels productive. The velocity is real. The ten-thousandth plausible diff teaches you to skim. And skimming is where it goes bad, because your job has now quietly become ratifying rather than authoring. 

Human in control isn't about governing the output. It's about governing the boundaries. You define, before the machine starts, what "right" means for your system — the patterns, tokens, architecture, standards — and the AI works inside them. What comes out is right by construction, not right after a marathon of corrections. Control isn't catching mistakes at the end. It's setting the constraints at the start, and making the governed path the fast path.

Drift is what losing control looks like over time

When AI ships code faster than anyone can review it, velocity goes vertical and underneath, the gap between what a team meant and what actually shipped keeps widening. That's drift. Drift isn't a mysterious force. It's the signature of a human out of control. Design and code start in agreement and quietly stop being the same thing — not because anyone chose to diverge, but because no one was commanding the divergence. Multiply that by the pace of AI, and your standards and your reality stop describing each other, discovered too late, at the worst possible time.

That's the real cost of "in the loop." Not a dramatic failure. A slow, compounding tax on trust. I devised the Production Drift Ratio (the amount of drift weighted by its complexity/cost to solve) to help calculate that tax. The first step to stopping drift is knowing it’s there.

The real cost of "in the loop" is not a dramatic failure. It's slow, compounding tax on trust.

My first answer was half the answer

So I built ReWeaver. My instinct was to meet that tax with proof: AI writes the code, we prove it's ready — same inputs, same findings, every keep-or-suppress decision logged as a human choice, in the code, with a name on it. In a stack made of probability, that determinism is the one part that doesn't move: the fixed point everything else is measured against, the one layer that can't hallucinate or drift between runs. That's not fencing the AI out. It's the ground it gets to stand on.

But I'd aimed it at one end of the work. ReWeaver met the AI at the door and checked what it carried out — real control, but only over what already exists. I was proving the cloth was true after it came off the loom, when the leverage would have been in setting the pattern before the first thread was laid. I'd built the layer that tells you the truth about what the machine made — not the one that governs what it's allowed to make.

Then I looked at Loom

Geoffrey Huntley built Loom, an AI coding agent, written in Rust, that runs autonomous loops: plan against a spec, do the work, run it, verify the result; from source to execution under one roof. He calls it the Ralph loop (or the Wiggum loop), and he's precise about where the human stands: not beside the machine rubber-stamping its output, but above it, programming the loop.

This isn't the sloppy end of AI coding. It's the disciplined apex of it — a master weaver at a loom built with human hands. And it forced me to admit what I'd been avoiding: AI isn't the thing to fence out. It's the thing to bring in.

Two centuries ago, the power loom took over weaving. Speed came at the cost of inferior cloth, vanished skill, craft traded for profit. But the loom wasn't the villain — it was just a faster way to make cloth with fewer hands. What changed everything was the relationship between the tool and the user. In a master's hands, the loom augmented the weaver. Left to run on its own, with a human nodding at whatever came off it, it stripped the weaver of both skill and agency. Same machine, opposite outcome.

In a master's hands, the loom augmented the weaver. Left to run on its own, with a human nodding at whatever came off it, it stripped the weaver of both skill and agency.

That's the difference between what Huntley does and what vibe coding has become — one in full command of a machine he built himself, the other a loop running while a human rubber-stamps and the craft quietly disappears. Not because the tools have to work that way, but because no one built the infrastructure to keep a human's hand on the loom.

One master, one loom, is not the enterprise

Huntley can keep his hand on the loom because he is the source of truth. One master, one intent, one loom. There's no question whose standard the cloth must meet.

Most software isn't woven by one master. Business holds the requirements. Product holds the flows. Design holds the system. Engineering holds the architecture. QA holds the bar for done. Each is a real source of truth; they don't always agree, and the AI has no way to know which to honor when they conflict. Design and code drift apart the moment no one governs the space between them.

You don't fix that with a faster loom — a faster loom with no pattern just produces the wrong cloth faster, from five directions at once. You fix it by weaving every discipline's constraints into the pattern before the machine starts, and keeping humans in command where those constraints meet: not one exhausted person checking every thread, but every discipline's standard made explicit, enforced, and held in human hands.

The vision, extended

So the vision had to expand, and Loom is what opened my eyes. Verifying the output was one piece — necessary, not sufficient. The two I was missing: let the AI be fully involved in the making, and put the human in control of the boundaries rather than just the outputs. Let the machine propose without limit — designs, structure, whole spans of work no human could draft by hand. But constrain it, before it starts, to the patterns a human defines, so its power runs inside the lines instead of across them. Then prove, deterministically, that it stayed there.

Propose without limit. Govern the bounds. Prove adherence. The proof is what keeps govern from decaying into hope. Do that, and drift — the tax I've spent years trying to hold back — stops accruing. Not because the loop slowed down, but because the human never let go of the pattern.

Not everyone can hand-build their own loom the way Huntley did, and they shouldn't have to. The work now is to make that relationship something anyone can pick up: an infrastructure in which AI's power is fully welcomed and human authority is fully preserved — and provable.

The power loom is here. It isn't going away, and it shouldn't. The only question left is the one weavers faced 200 years ago: whose hand is on it?

Let's build the loom that answers to the weaver. Not the AI.