How I work with agents

From CodeWhisperer's comment trees to a day spent in one main session, with a pool of agents working underneath it. What changed at each step, and the limits I added as it scaled.

case study · updated 8 Nov 2026
~/dansabin.com — chat Ask about this project

Can one person keep up with a pool of agents?

Most days, yes. Of 2,529 executor runs on this site, 43 stopped to ask, about one in sixty, so I can read every stop myself. I spend the day looking at one main session, and the rest of the work happens underneath it.

What do I read, if the agents do the work?

On one pass over this site's pages, an executor was asked to take the LinkedIn button off nine pages and leave a backlog note saying nine. It counted first. It found eight, and stopped before changing a file: "The LinkedIn button is on 8 content pages, not 9," so the note it was asked to write would be false.

The ninth page had a different button in that spot: "Back to dansabin.com", the agent page's way back to the project. The brief had counted one page too many. The Lead's reply was short: "Good catch." It relaunched with eight, and the agent page kept its way back.

In my experience a brief that's simply wrong, like this one, is the rarer case. More often a stop means the spec's original intent can't be met as written anymore, and the conversation it starts is where we find what's wrong.

One main session and the sessions under it I work from one main session, on my laptop or my phone through remote control. It holds ticket pools, open concepts and high level research, and spins off sessions, each in its own visible tab; one is a lead that approves routine pull request drafts. Each launches task executors. When an executor found the LinkedIn button on 8 pages, not 9, it stopped before changing a file, and the lead answered "Good catch" and relaunched with eight. Problems agents raise still come to me. Me laptop or phone remote control Main session ticket pools, open concepts, high level research problems agents raise come to me SESSIONS, EACH IN ITS OWN TAB Lead approves routine drafts Session one piece of work Session one piece of work stops to ask “Good catch” TASK EXECUTORS Executor LinkedIn button on 8 pages, not 9 stopped before changing a file Executor one task Executor one task Executor one task Executor one task One main session and the sessions under it I work from one main session, on my laptop or my phone through remote control. It holds ticket pools, open concepts and high level research, and spins off sessions, each in its own visible tab; one is a lead that approves routine pull request drafts. Each launches task executors. When an executor found the LinkedIn button on 8 pages, not 9, it stopped before changing a file, and the lead answered "Good catch" and relaunched with eight. Problems agents raise still come to me. Me laptop or phone, by remote control Main session ticket pools, open concepts, high level research SESSIONS, EACH IN ITS OWN TAB Sessions one piece of work each Lead approves routine drafts stops to ask “Good catch” TASK EXECUTORS Executor LinkedIn button on 8 pages, not 9 stopped before changing a file Executors one task each Problems agents raise come to me.
I work from one main session, on my laptop or my phone through remote control. It holds ticket pools, open concepts and high level research, and spins off sessions, each in its own visible tab; one is a lead that approves routine pull request drafts. Each launches task executors. When an executor found the LinkedIn button on 8 pages, not 9, it stopped before changing a file, and the lead answered "Good catch" and relaunched with eight. Problems agents raise still come to me.
When it's noticedWhat it costs
Before the first edit, while the executor countsOne question and a relaunch.
On the live pageThe agent page loses its "Back to dansabin.com" button, and the backlog note says nine, until someone looks again.

Most stops come with a recommended option. Of 585 times I picked from options where one was marked as recommended, I picked that one 529 times, about 90%. 10% is still a very wide margin of mistakes, and the price could land on the most critical issue. I don't know yet what rate I'd trust it to decide alone, only that it would be below 1%.

How would I know?

The measure I care about most is how often I have to undo or redo something, because that's where a wrong pick that got past me would show. The narrowest count is reverts: of the 173 pull requests merged on this site, none has been reverted (no revert commit on main, and no pull request titled as one), and I haven't had to tear out and rewrite a section of the codebase. That count misses the smaller kind of redo, a pull request whose first job is to fix the one that merged before it, and I haven't counted those yet. A team could count both from its own history.

A day

I use one overarching session to summarize ticket pools, open concepts and high level research. That thread uses interprocess messaging to spin off a pool of agents, and each one compacts between tasks.

I can deep dive into a smaller session, but the interrupt loops work well enough that I rarely do.

I use on-disk lockfiles to keep local builds from destroying my machine or my personal stacks, and to keep all the agents from swarming the main agent while I'm using it.

I also enable remote control on the main agent, so I can work across all my agents from my laptop or my phone without any middleware.

How I split the work

Sub-agents inside a skill. Development on the main agent bloats its context. A fresh agent loads the same rules, gets clear instructions for a single task, and knows what done means. The main agent stays lean with reports. Each layer gets a model sized to it: Fable on top, Opus for the agents and the wave reviewers, Sonnet for the task executors.

Sessions across skills. Each separate piece of work gets its own visible tab. Each one costs as much as a full Claude session, so the rule is to ask me before launching it.

A skill to route. A skill beats a rule for sizing a request, because it can do some research before it decides. The goal is to make the next right choice with some additional context.

Compaction as a seam. I compact when switching tasks, and agents between tasks. State goes into files first. The rules come back on their own afterward.

What I do with the time

Making decisions is a finite thing we can do each day. Reducing how many I make is how I get more done. So I read problems the agents raise, and I review what matters at each stage of the work.

For a design decision I'd often rather try it than read it, so sessions raise those as manual checks and I can experience the decision and see if it needs tweaks.

What I review

It depends on the stage of the work.

Early on I review the code closely. The AI builds on the code that exists, and problems in patterns and structure set the tone for all future code. As the codebase grows, my code reviews get less deep, because the foundation gives later code strong examples to follow.

Later, it matters more to review the requirements before a task starts, and to check the proposed design and task order.

The most important thing to review is the conflicts the skills find when they cross-check code, docs and specs. I don't let the agent resolve those on its own. Those decisions guide the most critical points of the implementation.

The limits I added

Each of these came when a new bottleneck showed up. Lockfiles and multi-agent coordination tools get built as things break, and they're my next area of investment.

  • The machine. Full test runs from parallel sessions overloaded it, so one full test run or git push happens at a time, behind a lockfile.
  • My attention. Full drafts from many sessions buried my tab. Now a lead approves routine pull request drafts. Problems agents raise still come to me.
  • My typing. Messages typed into my tab cut my own sentences in half. Sessions now write to an inbox, only when a stage is done or a batch is ready.
  • The browser. Agents opening Chrome kept prompting for passwords. Their runs now use a throwaway profile and a mock keychain.

How it got here

It started with CodeWhisperer: People were skeptical, as was I. I mocked AI for being bad, but I slowly started seeing value. I noticed I was writing a tree of comments and letting it fill in the code, probably my earliest spec-driven development. Then Amazon Q, where I learned to keep data in files outside of context; shell hacks that launched headless agents with instruction sets, tuned with the RFC 2119 key words; and Kiro and its spec-driven development. After Amazon, I rebuilt what I'd learned as Ponderly, and this website is where the dogfood was done. Running many sessions came fast: passing prompts by hand, then sessions messaging sessions, then one orchestrator over developer sessions, each in its own worktree and branch, so two Claudes never edit the same file and git resolves the conflicts.

What I'm working on now

I'm formalizing tooling for a three-layer hierarchy, and I'm running a third layer today. The question is whether it's better to manage the agents myself and be the loss function, the one judging every result, or to let an AI be my third layer, because it's a more predictable loss function and it doesn't get tired. The difference is whether I read a summary, or whether I summarize many agents in my own head.

Want the details?

Ask the window anything this page skips.