Delegate Like a Boss

The Build Loop, same as every rung — spec, direct, checkpoint, verify. Last rung you ran it once, end to end. This rung sharpens all four turns at once, because the loop already has a name in your working life: delegation.

You already know how to do this. You do it every time you hand real work to someone else and get back something you can use.

Think about the last time you briefed a junior colleague or an outside agency. You wrote down what you needed, why, and what "done" looked like — that's a spec. You put a check-in on the calendar before the deadline, because you've lived the version where the misunderstanding surfaces on delivery day — that's a checkpoint. And when the work came back, you didn't rebuild it; you reviewed it, with a particular attention you've spent years developing: does this match the brief, where did they guess, which guesses can I live with. That's verification.

Brief, hand off, check in, review. You've run this loop hundreds of times. The only new thing is who's on the other end — and this end is tireless, fast, and completely literal. Everything else transfers.

The bottleneck was never the code

Here's what surprised me most when I crossed over: I kept waiting for the moment I'd need to learn to code, and it never came. The bottleneck was never the code. Your real job has two halves, and neither one is programming.

The first is knowing what to build and why — the domain expertise and judgment you've spent a career building. The second is verifying the work came back right — actually checking that what the agent handed you does what you meant, the way you meant it. Both are yours, and I'll be straight with you: the second is the harder one. Directing a build is the fun part. Confirming it's genuinely correct — every time, without waving it through just because it looks finished — is the discipline that takes real effort. It's also the one that separates a working tool from a convincing-looking mess, which is why a whole rung later is devoted to it.

Picture the shape. Your intent on top, the agent's execution in the middle, your verification at the bottom. The agent's work is only ever the middle layer — held in place by your direction above it and your judgment below. You don't need to write code to run that. You need to know what good looks like, and to hold the line on checking you got it. You already do both.

Bring the expertise you were told didn't count

This reframe matters most to the people who were quietly told their expertise wasn't the technical kind. The HR manager who could have a working onboarding assistant if someone showed her how to structure what she already knows. The compliance officer whose policy library could become an operational tool almost overnight. The owner who knows the business cold and has no engineering team.

They have more reach than they know. The models are capable; the tools are right there. What's missing isn't talent — it's the bridge between "I chat with an AI" and "I direct work that ships." That bridge is delegation, and you already own every piece of it. Nobody hands out the permission slip, so take this as yours: if you can brief an agency, you can direct an agent.

Write down what you'd normally just say

One real adjustment, and it's the honest cost of the arrangement: the agent can only read what you write. It can't pick up your standards by sitting near you for a quarter, can't catch the tone of a hallway aside, can't absorb the taste you'd pass along by marking up three drafts. All of it has to land on the page.

That's less of a burden than it sounds — in practice it's plain-text notes, the working equivalent of a binder with labeled tabs — but it's the move that separates a clean result from a frustrating one. Write down what matters and what "done" looks like, then hand that over, and watch what changes when the agent knows not just what to do, but why it matters.

Two ways people go wrong here, and one fix covers both. Over-trust: agent output arrives fluent and complete-looking, and it can be wrong in ways a junior's rough draft never hides — polish isn't accuracy. Under-trust: you inspect every line so anxiously you'd have been faster doing it yourself. The cure for both is the checkpoint — a planned look at partial work, early enough to steer cheaply, so you're neither hovering nor handing over blind.

Size the job before you write the brief

The most common early mistake isn't a bad brief. It's a brief with no size on it.

With people, you set size by instinct: "quick and dirty by Friday" and "this goes to the board" are different assignments, and everyone hears the difference. An agent hears none of it. Give it an unsized brief and it will cheerfully build the cathedral when you needed the tent — burning your afternoon and handing you far more to check than the job was ever worth. And since checking is your half, oversized output isn't the agent's problem. It's yours.

So before you write a word of the brief, decide how much the job is actually worth — ten rough minutes, or a careful afternoon — then write to fit, and say the size out loud. "Small, ugly, working" is a legitimate and often correct instruction. Fix the appetite before the spec. The spec says what to build; the appetite says how much it's allowed to cost you.

Get that habit in place, and here's what you can now reliably make happen: real working software, sized to the problem, produced under your direction and checked by your judgment — without writing a line of code. You're not being replaced. You're being promoted.

→ The companion — In Tropo: Your First Delegation — walks you through one real hand-off: brief, checkpoint, review, with the appetite set first.

Power Play

Don't guess the appetite — make the agent price it for you. Before you commit to a version, ask:

"Give me three ways to build this: a rough one I could have in ten minutes, a solid one worth an hour, and a polished one. For each, tell me what it does, what it leaves out, and how much of my time it'll take to check."

Now you're choosing the size with real options in front of you instead of guessing — and you'll be surprised how often the ten-minute version is the one you actually needed.

Terms worth knowing

• Agent — an AI you run on your own machine that can take actions — create files, edit documents, run tasks — not just answer questions. The specific tool is swappable; the loop is not.
• Spec — the written brief you hand an agent: what to build, why, and what done looks like.
• Checkpoint — a planned look at partial work, timed early enough that steering is still cheap.
• Appetite — how much time and polish a job deserves, decided before you write the brief. Borrowed from how product teams size work.