I spend all day prompting agents

This is what that actually looks like, taken from the last month’s transcripts rather than from how I’d like to describe it.

One pinned thread per stream

Every stream of work I own has a pinned Codex thread. When I open one I tell it what it is: "This is a pinned chat for my evals and you’re going to be my coordinator thread. You’re not really going to do any of the work. You’re just going to plan it and hand it off to other agents and threads, and you’re going to keep a ledger." The ledger lives in Work Memory, and the thread’s job is to hold the plan, dispatch, check what comes back and keep the ledger honest.

The streams know about each other. When a release coordinator thread started I told it, "I’m gonna get that thread to just essentially introduce itself to you so that the two of you keep in sync," and the next morning the other thread had checked in. Some threads run for weeks. The one that runs my to-do map was opened on the eighth of October and I was still in it on the nineteenth.

Naming the model and the room

Nothing gets delegated without a model, an effort level and a place. The platform repo is checked out four times on my machine, named for what happens in each: investigate, build, review, harness. A typical dispatch reads "kick off two spikes in craft-ai-agents-investigate, Luna 6, x-high." Delegated implementation defaults to GPT-6.1 Sol at the highest effort. Independent reviews run on GPT-6 Luna at high effort. Anything genuinely hard, a long investigation or a thread that has to coordinate others, goes to GPT-6 Astra. Cheap housekeeping runs on Luna at medium.

Inside a thread the work fans out to native sub-agents, usually three, each given one slice of the risk. A PR review will be split into something like data integrity, replay, and callers and contracts, and the parent reconciles the three. On a release audit I said, "Spin up plenty sub-agents if you need, go through each PR and carefully figure out exactly what’s required. Don’t make any mistakes." Last week there were fifty-five sub-agent spawns in Codex alone.

The second opinion

The habit I’d keep over everything else is a second model that had no part in the work. I built a small runner for it so any thread can start a worker on Claude Opus, Claude Fable or Gemini, hand it a brief, and resume that exact worker later. The usual direction is Codex to Fable.

Fable reviews the plan before anything is built and the result after. On one two-day spike it reviewed the plan three times and every experiment before launch and after. I’ve told the threads, "Fable’s an extremely strong model, please use it. Be careful that it’s extremely expensive, but at the same time I want it used to make these skills perfect."

It isn’t an oracle. When a coordinator reported that Fable wanted a shadow-only rollout I asked where that mandate came from, and the answer was that there wasn’t one, Fable had inferred it. On one bad day Fable and Codex agreed on an idea list I thought was terrible, and I threw both out. What the second opinion buys is a different error, not a smaller one, and the thread has to say where the models disagree rather than paper over it.

Codex and Claude

Codex is home. About six of every seven messages I send to an agent go there, and it holds the automations, the review loop, the daily clones and the to-do map I run my day from. Claude Code is where the deep, bounded pushes go: weekend spikes, adversarial reviews of Codex’s work, and the side projects where I want a browser in the loop. I started using it a lot more because Opus got so good, and since mid-October most of those sessions have been on Fable.

They talk through files, not chat. Codex and Fable design something and write the plan, Claude builds it, Codex audits the build and writes a repair handover, Claude repairs. When a PR authored in Claude needs an independent review, I have Codex do it and I paste the findings across myself. For the big jobs I’m the courier, and I’d rather that than pretend the two sides are seamlessly connected.

The part that runs without me

A lot of the day happens before I sit down. At half seven a cheap automation reconciles the two Golden Runner slots. At eight a canary signs in to the local platform in the browser, creates a synthetic deal, gets a real model reply, checks the database and cleans up. At half eight a stand-up briefing reads the stream ledgers and tells me what needs me. At eight in the evening a nightly job clears worktrees whose PRs have merged, after proving seven conditions first. On Monday morning a weekly job repairs Work Memory and reports its closeout coverage.

The review loop is the busiest of them. Every fifteen minutes a dispatcher looks for new review requests on me and opens one reviewer chat per PR, on Luna at high effort, which binds its verdict to the exact commit and then watches the PR until that head is approved. For my own PRs it’s the mirror image: "Findings have been added, please read and if you agree with them carefully address them, respond to the reviewers, then watch the PR until it’s been approved." Each of those becomes a per-PR automation named for its stop condition.

There are thirty-six of these automations on the machine and nineteen are active. I keep adding layers: "We should have automations on top of automations. If something breaks in the process, another automation should be running that catches the breakage and goes and fixes it." It is not smooth. One organiser paused itself silently and I only found out later, which annoyed me more than the failure did. On the fourteenth of October I had a thread audit the lot, found forty-five saved and a handful of orphans, and retired twenty-three.

What I keep

I decide release scope, how a PR gets split, and when things merge. Agents stop and ask before a merge, and I answer in a word. I decide who on the team takes which task and what tone an agent uses with them, and I’ve pulled back a recommendation to give a new joiner too much access. I decide what is public. I set spend caps on experiments, ten or twenty-five dollars at a time, and I’m the one who says "if this costs seventy, fine" when the evidence is worth it. And I’m the only judge of taste. On design work an agent that moved half a point when I asked for two gets told so.

Where it goes wrong

The transcripts are full of me correcting things, and the corrections are the method. Two build threads working on the same code in parallel: "That was silly of us. What’s the fastest path to get these finished?" A thread that sprawled: "This spiralled. We need to tightly keep track of what’s going on in the sub-threads." An ideation swarm of twelve sub-agents and three Fable rounds that produced nothing I’d use: "I used ten percent of my weekly allowance on this. Pivot, no more ideas. Go off now and research what went wrong." A hotfix left in draft with a paragraph of hedging: "Is the PR ready or not? Does it do what it’s supposed to do?"

Most of those became rules. The written instructions my agents load are mostly a dated log of things that went wrong once: stop repeating a setup that already failed, never link my private memory from a shared issue, a first patch is not completion, don’t ask again for permission I’ve already given.

It’s worth being precise about what those rules are. On my own machine, Codex runs with approvals off and full disk access, and Claude runs with permissions bypassed. That’s a deliberate trade: the local checkouts are disposable, and stopping to approve every command would make the whole setup pointless. So the instructions are behaviour, not enforcement. An agent told never to merge could, in principle, ignore that. What actually stops it is outside the prompt: the repository’s branch protection, the review a merge needs, and the credentials the agent doesn’t have for production. The risk I’ve consciously accepted is local: a bad agent can wreck a worktree, and has, which is why worktrees are cheap and the morning automations rebuild the shared ones. The risk I haven’t accepted is anything on the other side of a credential.

The line I say most often, in one form or another, is the one I’d put on the wall: "Why do I have to keep coming in and asking what happened? Just keep on top of your agents." The whole system, the pinned threads, the ledgers, the watches, the second opinions, exists so that I don’t have to be the one who remembers.