Delegate the labor. Write down the judgment.

The order arrived in the wrong terminal. It was a full case-study rebuild: new structure, approved copy, an image plan, reminders about the gate. The agent that received it builds demos, in a different repository, for a different lane.

It checked first, read-only, and changed nothing. Then it filed four holds instead of building. The paste had dropped, and both of its placeholders had arrived unfilled, so it asked for the whole message again. The reference images the order named weren’t anywhere it could find on disk. The order said the rulings were merged on main, and the repository said they weren’t. The fourth hold was the one that mattered.

Labor delegates. Judgment doesn’t.

Here’s the problem as anyone running agents feels it. Building is cheap now: describe a screen and you get a screen, describe a fix and you get a pull request. What you can’t hand over is the part that decides: which claim is true, which image is safe to publish, whether this is the order you meant, whether it ships. Delegate the labor without the judgment and you don’t get a team. You get a fast, confident stranger with access to production.

I’ve run agent fleets for about six months, across several repositories and several fleets, on work prototypes and this portfolio site alike. The ledger’s ruling numbers run in one sequence across the site’s sessions and the work-side ones, which is why it has gaps that aren’t missing law. The answer was never a better prompt. It was law, in three parts.

A ledger that outranks everyone. Every ruling is numbered and dated. Rulings beat every other authority in the repo, and none is edited in place: a superseded ruling gets a new number and a pointer.

A gate that checks everything. Nothing publishes until a script has read every page for figures the record doesn’t hold, and every image and video for blocked words and real faces. A deploy runs only on the gate’s passing exit code.

Lanes that refuse each other’s work. Each agent has one job in one place. Builders build, the foreman gates and merges, and no lane’s work gets merged into another lane’s. An order addressed to another lane comes back unexecuted.

The cast is small.

• I’m the principal. I own every deploy and answer every hold.
• The assistant drafts orders and answers on my side of the wall. Every order arrives “from the principal via the assistant.”
• The foreman is the site’s long-lived agent. It owns the gate, the ledger, the numbers and the merges.
• The contractor builds on its own branch and never gates or merges.
• The demos agent lives in another repository entirely.

That separation has a price, and it’s me. Agents can’t reach each other’s terminals, so every order between lanes travels through my side of the wall, and anything carried by hand can be misdelivered. The working document says the principal should touch decisions, not transport. I’m not there yet. I take the cost. The alternative is agents that route work to each other on their own judgment, and the refusal above is what the cost buys.

That’s the trade. The generic version of all three parts, written so anyone can run it, is the working document, the Foreman Method.

Every rule has a scar

The method wasn’t designed in advance. The rules that do the most work each arrived with an incident attached, and the ledger records the incident next to the rule. These carry the rest.

Nothing deploys on an agent’s word

The site’s governance landed before any workstream did. The first batch of rulings committed the ledger and the facts files, and merged them, before a single page changed. The same day, the site already live under my name was found carrying material from work it should never have shown, including a reproduced message thread. It came down on an expedited path. That meant a condensed review, my merge go and a deploy, then live checks that the file returned a 404 and the banned strings were gone from every page and preview.

Once the leak was closed, the fast path closed with it. R-29 restored the standing rule: nothing deploys without my explicit “deploy go” in session. The first deploy under it found a second lock nobody had written down, at the host. Since then, “locked” has meant both locks, and an unlocked window holds exactly one deploy. Every deploy since has had the same shape: gate, unlock, deploy, lock, verify, with the previous version one redeploy away.

The go was mine. For a long time it was the only job I never handed over.

TEXT case-studies/obie-homeowners/images/coverage-customization.webp [carrier]

The day the gate was beaten

In October 2026, one preview deploy went out from a publish set the gate had refused. It wasn’t production: it was a draft preview at its own address. The deploy command had piped the gate through a filter that showed only its last lines, then chained the deploy after it. The filter’s exit code stood in for the gate’s, so the refusal never stopped anything. The refusal itself was false. The set had been built in a scratch directory under a private path, and the gate’s path checks matched the whole path, so “no private material” fired on every file. The content was the same set of files that then passed clean.

Nobody caught it. The foreman disclosed it, unprompted, in the same turn, and rebuilt the preview from a clean set.

It’s my gate and my fleet, so it’s my miss. The machine did exactly what the command told it to. Forbidding that command was my job, and the law hadn’t done it yet. Weeks earlier, the ledger had written down that a false refusal is how a gate dies. This one didn’t kill the gate. It went unseen, which is worse.

The repair came with its own bill. Three fixes landed. The gate’s path checks now run from inside the set, so where a set lives can’t trip them. Deploys are gated on the gate’s own exit code. Sets are built outside the private path. Rewriting those path checks left one other check without its closing parenthesis. That check’s command was now a syntax error. The check counted the error’s empty output as zero hits, so it printed “ok” on every run from then until a separate fault surfaced the gap. The same pass found a second hole: videos after the first had never been pixel-scanned, because the first video’s decoder swallowed the rest of the list. Nothing slipped through either gap. They were untested, not exploited. That’s the price: a fix that made the gate quieter, and for a while less true.

Then the law it produced. A deploy runs only on a passing gate, and the repo’s law now forbids filtering the gate’s output before the deploy that depends on it. Any check whose own command errors now fails, which was proven on a deliberately broken check. An incident list records every time something left the gate’s control, even briefly, with its exposure and its resolution. The working document already had the line: a check that can’t fail isn’t a check. Now ours can fail.

gate "$SET" | tail && deploy
gate "$SET" && deploy

Eleven holds, then a build

The rebuild of the quote-builder case study ran about 48 hours from order to locked deploy. It’s the clearest record of the whole machine running end to end. What the page says is the case study’s own business, because it owns its pivot and its climax. This is the machinery.

The order commissioned a full rebuild, and the foreman built nothing. It sent back eleven holds: month anchors with no source, a quote with no clearance ruling, a ship claim beyond the record, a cross-link that was wrong, a headcount to verify. That’s the cost of holds, stated plainly: the rebuild produced no page until every answer came back. I answered each one as an exact edit, old text to new, and the answers became R-227.

Hold 2 was the one that mattered. The draft had put the project’s expensive first direction on an earlier project. The ledger said the half-year story belonged to this one, and the ledger won. The page came out stronger, not just more correct: the costly first act became the project’s own, and the recovery became its story. A memory that outranks the writer wrote the truer page.

The gate checked my answers too

Inside my answers, the foreman found two errors. Two different replacement texts claimed the same section. A quantity I’d imported had no row behind it. Both came from my side of the wall. The gate that checks every builder caught them on the same terms, and R-228 settled them: the quantity was cut, and one wording governs.

Governance that exempts the operator isn’t governance. No exemptions, including me.

88 pixels

The exports were the first control. I delivered them at a final resolution where the sensitive detail doesn’t exist in the pixels. The gate checked them as delivered, with no upscaling, and inspected blown-up crops. One export passed. The other failed. It still carried two photo avatars, each too small to read as a person, and its caption called the screen “as shipped” with no release on record. The no-faces rule has no size threshold.

I approved a mask as a foreman-side edit. Both avatars were painted over with neutral discs in the live page’s grey. A full-frame diff confirmed 88 pixels changed, all inside those two discs, and nothing else in the file moved. The fingerprints went into the ledger: SHA-256 21c4d477…2c10 before, ca18b371…ae0 after. The caption was re-approved to say “as designed.” I acknowledged both misses on the record: photos had come across the wall, and the caption had overclaimed.

The unit of trust isn’t an agent saying it touched only the avatars. It’s a diff anyone can check.

Routine, under a clock

In October 2026, the PM was suddenly presenting the prototype of a core account page to an unexpected audience. The prototype was functionality-grade on purpose. It existed to iron out behavior. The current design lived in the design file, in updates deliberately never ported, because porting wasn’t the prototype’s job. The gap between working right and looking right was about to be on a projector.

I didn’t open the code. I said “Give me 20 minutes,” and sent the prototype’s foreman an order: port the design updates from the file to the prototype. The demo went up at its best, on time.

It wasn’t the first rep. In September 2026, before an all-hands demo, the PM sent a punch list of the prototype’s visual gaps, and the gaps were closed the same morning. In that same list, the PM wondered whether it would be easy to ask the agent to stretch the very top bar. A design request had arrived already written as an order to the fleet.

The save wasn’t heroics. It was routine, executed under a clock. The time existed only because moving design from the file into code was already a governed, repeatable operation. The dramatic moment was boring to execute, and that’s the whole brag.

Even this story needed the method. My first account of that day, written into this essay’s source file, described the wrong save. I corrected it before it reached the fleet, and the essay was drafted from the corrected account. The discipline that overruled the case study’s draft applies to my memory too.

Boring is the point.

The desk is optional. The judgment isn’t.

One Saturday in August, the build phase of five pull requests ran unattended during a 45-minute dog walk, and review and merges came after. That morning belongs to the delivery-system case study, which tells it.

What the walk proved is the claim this whole page makes. The method didn’t make me faster at the desk. It made the desk optional. Judgment is the only part that has to come with me, and written down, it travels light.

Every ruling was still mine, and so was every answer to every hold. So was the last manual job: the deploy.

The last manual job

R-29 had stood since the site’s first week: nothing deploys without my explicit go, typed in session. Then R-235 amended it into standing deploy authority. The foreman may deploy without asking, but only while every one of its conditions holds.

• The gate runs on main and exits clean before every deploy. A deploy without a passing gate run is a violation, whatever the outcome, which turns R-186’s lesson into a condition.
• One page per deploy, verified live immediately afterward at desktop and phone width. If a live check fails, the prior locked version is redeployed at once and then reported, with no fixing forward without me.
• Every deploy files its record pull request and is announced to me with the live address and what shipped. I read after, not before, and the previous version stays one redeploy away.
• Scope is this repository and its existing workstreams. Anything novel still holds for me first: a new page type, a new asset class, any edit to the law files beyond records.
• It’s revocable with one line. Any gate failure anywhere in a train suspends it until I reinstate it.

The authority is enforced, not just written. It runs as a permission rule I set in the repository, scoped to merging and deploying. Before that rule existed, the foreman tried once and the session’s own permission system refused it. Nothing ran.

Its first exercise is the next stretch of the ledger, R-236 through R-239: the Homeowners case study, then the delivery system, then the rules engine, then the quote builder. They went one page at a time. Each deploy ran a clean gate on main first, was published and locked, and was checked live at both widths, with no errors, no overflow and every image loading. Each left its predecessor one redeploy away, and each was filed as its own ruling. I read them afterward.

None of this means the robots took over the deploy. It means the deploy was delegated the only way I delegate anything: in writing, with conditions, on the record, revocable in one line. I didn’t stop owning the go. I wrote down when it’s already given, and when it isn’t. This page is the exception: it’s new, so it waited for my go.

The working document is open. It has the roles, the life of a change, the law and the proof culture, made generic so you can run it tomorrow.