Coding agents wrote almost all of Fractal's code: 329 commits between March 27 and October 5, in three bursts. Fractal is the infinite-zoom drawing canvas I build on the side, with a Go server and a TypeScript client. Beside the code sits a plans/ folder that git never sees. It holds 40 files and about 9,000 lines, and every feature now starts as one of those plans.
All my side projects split the work the same way: agents research, suggest options, and write the code, while I make most of the design calls. So every plan waits for me before it's built, and every build comes back to me when it's done. Reading all of that is the slow part, so I set the limit by what I can read: at most two agent sessions per repo, and at most two projects at once.
A feature starts as a plan#
Every feature goes through the same steps: a plan, my approval, then the build. The work happens in a session, one running conversation with Claude Code or Codex, and I don't prefer either. Both get the same agents and skills, the written instructions the agents follow. A small tool I wrote, agentsync, generates each tool's copy from one agents/ folder in the repo.
A session usually starts with what I want to build next, or with something from the backlog. I tell it to have the architect agent write the plan, and then we go through some grill rounds. In a grill round, the agent asks me one question at a time about the plan, each with the answer it recommends, and the plan changes to match what we settle. Plans that are hard to undo get two more checks before I approve them: grill rounds the agents run without me, and one review from the other tool. Once I'm happy with the plan, I tell the session to orchestrate.
Orchestrating means the session runs the build without writing any code itself. It hands each part of the plan to an engineer agent, then to a code-reviewer agent. If the fixes still haven't settled after three rounds, it commits what's been reviewed and verified, and the rest comes to me.
The repo's rules hold that shape. I approve the plan before any code is written, and the engineer agents carry out the plan; they don't write it.
Two sessions per repo, two projects#
The cap comes from how much I can read, inside one repo and across projects. In a repo I run at most two agent sessions. I like to know what's going on, so almost always only one plan is being built at a time. When there are two sessions, one is the planning lane, where I work on the next plan, and the other is the build lane, which builds the plan I've already approved.
The two lanes need me at different times. The planning lane asks me each question in a grill round. The build lane comes back to me when it passes a problem up, or when the run ends.
There is only one build lane because a second would mean two diffs to read against two plans.
The same reading limit caps how many projects I work on at once: two. With a third, I can't give any of them real attention, and switching between them gets to be too much.
What waits for me#
Some decisions aren't the agents' to make, and when a plan hits one, the work stops and waits for me. The zoom rework hit one. Agents were comparing two ways to draw the canvas when the work went on hold for a question the plan said was mine: when paint from different zoom levels overlaps, which one wins?
I decided it's simply the order things were drawn, at every zoom level: whatever came later wins. A later erase cuts through earlier paint, and later paint covers the hole, even paint drawn while zoomed further out. The eraser post shows what that looks like on the canvas.
Testing works the same way. The work could merge only once every target was met, or once I'd signed off on a miss. One check had to pass on my iPad, which I didn't have on hand, so on October 1 I signed off on merging without it. The work merged on the browser checks alone, and the iPad check still hasn't been run.
Rules that keep the work in scope#
A separate set of rules keeps what comes back to me focused enough to review. The first limits what a reviewer agent can block. A problem it finds can stop the work only if it comes with three things: a trigger the system really receives, a result you can see, and proof. Proof means the exact file and line, plus a failing test or exact steps to make it happen again. Anything less gets written down, not fixed.
Once a plan is approved, it can't change while it's being built, and a fix can't sneak in new work either. A fix round is one pass where the engineer agent fixes what the reviewer found, and only that. If a round starts adding things the plan never asked for, the session running the build stops and cuts the work back to the plan.
Plans get the same treatment in the grill rounds the agents run without me. Each round should settle open questions, not add new scope. If a plan keeps growing from round to round, the loop stops and says so.
Limits can also go into the plan itself, before the build starts. When I approved the second performance plan, I wrote in it that the agents could run the whole thing on their own, start to finish. The same section says what they could keep: an experiment stays only if it wins when measured. It also lists what was off limits: changing how canvases are stored on disk, redesigning the background workers, adding new libraries, and building a general-purpose cache or networking layer.
The failure I'm guarding against#
All of this guards against one failure: merging work nobody read. It doesn't usually happen, because I review the plans and the work, but it could if I got too ambitious: four agents running in parallel, then merging everything because there was too much to review. Fractal has already had at least one diff I never read. It's a May commit whose whole message is "agents", and the rate limiter post covers what was in it.
The same loop elsewhere#
Fractal isn't the only place I work this way. I bring the same habits to my day job at Tag-N-Trac. This blog runs the loop too: a writer agent drafts, an editor agent reviews, and publishing is my call.
What the cap costs#
I could run more sessions and don't, so the work goes slower. At this pace the performance work took almost a week, and the eraser plan took two days.
Two is a number about me. The tools would take a third session without complaint, and its plan and diffs would come back to the same reader.