The Hoist

For the first time in a while, I have open headcount. A principal engineer role, and a very specific shape of candidate in mind.

I know this shape well. I've hired it before. I'm looking for someone who has internalized algebraic type systems. Someone who has gone deep enough on fundamentals to find their way to Nix on their own. Someone with second-order thinking baked in. And critically: someone who will pull with me into the product space we're building, not someone I have to drag. That last one is the hardest to find and the most important to get right.

I know how to find that candidate. I've done it before. So I did what I've done a dozen times: I built my sourcing tool.

With Claude Code, the build took a couple of hours. Role definition, candidate evaluation criteria, enrichment, outreach generation, and the whole workflow. It worked. And then I sat down to use it.

Here's what I was actually doing, step by step.

I'd open a candidate profile and read it, enough to judge whether this person was worth enriching, because enrichment costs something, and I've sourced enough candidates to recognize a long shot. Decide yes. Hit the button. Wait. Read the enriched profile. Think about what would actually land with this person, what their career arc told me about what they cared about. Craft the outreach. Send it. Move to the next candidate.

Every tool worked. Each step did exactly what it was supposed to do.

But look at what I was doing: making the cost judgment, synthesizing the enriched data, inferring motivation, crafting the message. The tools were handling the fetch operations. I was handling everything else.

I wasn't using tools. I was the agent.

That's the ceiling of tool-level thinking, and it's easy to miss because everything is working. Working isn't the same as right. I'd built the whole thing in two hours, fast and clean, and the speed had masked the problem. The tools weren't for me. They were components waiting for an agent I hadn't built yet.

The move from tool-level to flow-level is what I call the hoist: the shift from building AI-assisted steps for a human operator to building agent-executable flows governed by a human arbiter.

The orchestrator runs the workflow, deciding when to invoke which tool, synthesizing outputs, and providing the connective tissue. If the orchestrator steps away, nothing runs. That was me, clicking through candidates, holding the workflow together by hand.

The arbiter governs the workflow. The agent does the work, makes decisions, and moves the flow forward. The human re-enters at the points that genuinely require judgment. The arbiter isn't out of the loop. The arbiter defines the loop.

Here's what that governance looks like in practice.

At first, the agent surfaces everything: every judgment call, every place it could reasonably go either way. You approve, adjust, and redirect. You watch how it thinks and learn where its judgment is solid, where it isn't, and where its blind spots live.

Then you start extending authority — not all at once, not everywhere, but in the specific places where you've seen it get it right enough times to trust the pattern. The agent stops surfacing those decisions and starts making them. Your interventions get fewer. The flow runs longer without you.

Every good call the agent makes without you is leverage you didn't have yesterday, and that leverage compounds.

This is the shape of a real AI product: one that operates with genuine capability, surfaces the moments that require human judgment, and earns autonomy incrementally where trust has been established. The hoist is how you get there.

The irony is that if you're building with Claude Code or Codex, you already know what this feels like from the inside. You're the human in that loop, intervening when your judgment is needed and stepping back when it isn't.

That's the hoist. You're living inside it every time you use these tools to build. You just haven't applied the same model to what you're making.

One honest constraint: the hoist requires you to externalize your judgment. The expertise you've been applying instinctively, pattern recognition built over years in a domain, has to become something the agent can use. Rules, heuristics, explicit criteria for the calls it makes versus the calls it surfaces to you.

A lot of what I know about that principal engineer shape, I don't know I know. It fires before I can articulate it. Teaching that to the agent is real work, and right now it requires someone who can build. The tooling won't do it for you.

That's also what makes this moment worth paying attention to. The person best positioned to build the flow-level agent is the domain expert who can also build, someone who knows what good looks like and can encode it. If you have that combination, this is the moment to use it.

Look at what you've built. Ask honestly: Is my attention still the thing binding this workflow together?

If the answer is yes, you haven't finished the design. The next move isn't another tool. It's the handoff architecture that lets an agent run and a human govern.

That's the hoist.