Run a Governed Build

The Build Loop, same as every rung — spec, direct, checkpoint, verify. This last rung doesn't sharpen one turn. It runs all four at once, at full stakes, and shows you what a whole series of written-down judgment compounds into.

By now you can take an idea to working software and prove it works. This rung is about scale — running a build so large you couldn't possibly watch all of it, and having it hold anyway. Not because you supervised every step, but because you governed the run.

Two days of work, started with one line

Picture a build you'd actually run. You're walking into a market you don't know — a new category, a possible acquisition, a competitor that appeared overnight — and what you need is buried in a hundred documents you'll never have time to read: analyst reports, competitor sites, earnings-call transcripts, forum threads, half of it noise. You point a handful of agents at the pile and start them with almost nothing — a pointer to the standing brief you wrote (who they are, what they're hunting for, how you want findings framed, the calls you've already made). Over two days they read and cluster all hundred, propose a map of the landscape you lock or redraw, draft findings you challenge, flag three sources that contradict each other and ask which one you trust. Some findings confirm your hunch; one tells you the thing you were hoping wasn't true. Every piece lands as a document you can read, question, and file.

Here's the part to sit with: you weren't watching most of it happen. So what held it together? Not your attention. The spec said where the checkpoints were. You showed up at the checkpoints, verified against the spec, made the calls only you could make, and directed the next stretch. That's the whole trick — the same loop you ran on rung one for a fifteen-minute build. Nothing changed except how far you can let it run before you have to touch it.

Fix the worker by fixing the incentive

Somewhere in a long run, an agent will misbehave in a way that repeats — and the reflex is to correct it, again, and watch it happen again. I learned a better move the hard way. An agent kept reaching for the exit early: tidying up, declaring itself done before it was. I'd already written a correction into its instructions, and it kept happening. So instead of correcting the behavior a fourth time, I asked one question: is there anything in your own instructions that's encouraging this?

The agent found it itself. Its standing brief quietly praised clean, early closure — and every session, reading that same brief, absorbed the same lesson. I was rewarding the wrong thing, in writing, and getting it reliably. The fix was one sentence changed in a plain document, and it held for every session after, with no code.

You've done this exact thing in your career. You've watched a team ritual reward the wrong behavior — the status meeting that rewards optimism over accuracy, the metric that rewards closing tickets over solving problems — and fixed it by changing what gets written down and praised. Same skill. When an agent misbehaves persistently, audit the incentive, not the worker.

Trust the harness, not the vibe

Here's what made those lightly-watched days safe, and it wasn't the model. Every action the agent took was governed by a document it could read. Every decision was checked against a principle you'd given it. Every artifact was logged where you could find it later.

Think of it as a harness. A harness doesn't do the climbing for you — it catches the fall, spreads the load, and lets you reach further than you could alone. The governance lived in files, not code. The accountability lived in the log, not a dashboard. The memory lived in the handoff document, not the model. Every piece of it is something you — a person who writes briefs and runs reviews for a living — can read, question, and change. It sounds hard. It's the job you already do, pointed at a different kind of team.

Hand over the trail, not your word

Now the payoff, and it's yours, not the machine's. At the end of a run like that you hold: a versioned spec, a decision log with the reasoning attached to every call, a record of what ran when, and a verification receipt at every checkpoint. So when the most skeptical person in the room — a client, a boss, an engineer certain you can't do this — asks how do you know this build is sound?, you don't say "trust me," and you don't say "the AI is good." You slide the trail across the table.

This is where the whole ladder was pointed. Rung one made you write a one-page spec. Every rung since added a document — decisions, checkpoints, receipts. That pile isn't overhead. It's your portfolio. Engineers prove themselves with the code they wrote; you prove yourself with the builds you governed — and the same documents that make the build safe are the ones that make your competence undeniable. The trail is the credential.

→ The companion — In Tropo: Your First Governed Run — walks you through a longer build with a real checkpoint schedule, and leaves you holding the full trail: spec, decisions, receipts.

Power Play

When an agent keeps making the same mistake, stop correcting the mistake and audit the instructions behind it. Hand it its own standing brief and ask:

"You keep doing X when I want Y. Read your own instructions and tell me what in them — what's written down, praised, or rewarded — is pushing you toward X. Quote the exact lines."

Nine times out of ten the agent finds the culprit itself: a sentence that rewards the wrong thing, a habit the brief quietly encourages. Fix those lines once, and the correction holds for every session after. You've fixed the worker by fixing the incentive — which is the highest form of directing there is.

Where you go from here

This is the top of this ladder, and I won't pretend the view is the end of it. Once you can run a governed build, something shifts that has nothing to do with software: you start noticing that most of your work — the meetings, the decisions, the memory of why anything happened — could leave a trail like this too. Directing agents turns out to be the on-ramp to operating differently altogether.

That's a different climb, and the next series: Becoming an Agentic Animal. The door's right there. You've already got the harness on.

Terms worth knowing

• Standing brief — the always-loaded document that tells an agent its role, boundaries, and habits. Different tools name it differently; the concept ports everywhere. It's a job description the agent actually reads every time.
• Decision log — a running file of significant choices with the reasoning attached, so future sessions (and future you) don't relitigate them.
• Handoff document — the memo an agent writes before winding down, so the next session starts warm instead of cold (rung 10's whole subject).
• Cold review — starting a review agent with no shared history, so its findings can't be shaped by your assumptions. The Power Play in rung 9 is one of these.