On Keeping a Crew of Machines at WorkFrom an idea to batch 21 · Assigning work, handoffs, and rework

On the afternoon of October 31, Harlo was still only an idea for a game on a foldable phone. By the time I went through the records on November 3, work had reached batch 21. Labels like “batch 9” and “batch 10” look rather dull on their own, but open them up and they often turn out to be small things: frame rates dropping near a space station, or a camera in the wrong place. A game probably makes its way from an idea to something you can play on your phone somewhere among all those requests for changes.

Harlo combines nurturing and management gameplay. Unfold the phone and you can pilot a ship yourself, or watch it cruise between space stations; fold it shut and the outer screen keeps a face and a clock, with a response when you tap it. I like the gesture itself: the same phone holds a galaxy when open and leaves just a little companionship when closed. Whether it is actually fun is something I still have to find out by installing each new version on the phone.

I say what is wrong; the lead session turns it into tasks

I am the only person making Harlo. I leave the code, design documents, and assets to AI agents: assistants that can take a task and use tools to do the work. There are two levels of responsibility here that are easy to confuse. I decide what the game needs, play it on my phone, and give feedback; the lead Claude session turns that feedback into tasks, then assigns them to workflows and Codex. A workflow, in this context, is a group of assistants organized around a task, with some doing the work and others checking it.

I did not start by opening up dozens of tasks at once. Work on the concept and plan began at 16:36 on October 31, shifted to a prototype at 17:43, and only reached the stage covering six areas of gameplay at 21:08. The lead session assigned each area of gameplay separately, while a separate workflow wrote design documents. From the evening of November 1, batches 7 through 18 focused on refinement; from midday on November 2, the work was grouped under “in progress.” Across these five stages, the earlier plans set the scope for the code that followed, while later playtests sent me back to revise the earlier ideas.

Once a batch is handed back, a review agent runs tests and looks at screenshots. The lead session then merges the work and installs it on my phone again. Before batch 21, for example, Codex worked in parallel on a new player ship model, a crew roster, and a startup sound. All three were handed back at noon, then integrated into the game in that batch. An asset being finished does not mean it is already in the game; there is still an integration step between the two. Unless that step goes on the task list, the files sit there and I still see nothing new on my phone.

Parallel work does let several things move forward at once, but it also means they compete for shared resources. The rule we eventually kept was a maximum of two coding tracks, with only one allowed to operate the simulator. Batch 21 followed this arrangement: one track checked the visuals, the other only compiled, and after the two were merged, all 254 tests were run. The limit hardly fits the idea that opening more agents will make everything faster, but the reason is quite concrete: with a single simulator, both sides cannot assume the screen still shows the state they left it in.

Work handed back can still be sent back

Even at the prototype stage, we adjusted the lighting on the actual phone, removing blur and an overly bright glow. Things were no easier later: batch 9 tracked down and fixed frame rate drops near space stations, and batch 11 added collisions between ships, stations, and platforms so they would not pass through one another. The trouble is that a screenshot can make a ship look quite presentable without showing the stutter as you fly along. A review agent can check some of this for me, but I still have to pick up the phone and try moving my fingers across the screen.

We also changed how we made the ship models. I felt the original ships lacked detail, so I first generated design images in Jimeng using prompts written by Claude. Codex tried building a ship from scratch. Later, we switched to having Tripo generate a base model from a design image, then gave it to Codex to refine with 3D tools such as Blender: adding a glass canopy, cockpit seats, and glowing components, then removing excess polygons. At the time of this tally, four new ships were still being swapped into the game; I could not yet count them all as installed.

That change of mind also led me to break the tasks down further. The image establishes the appearance first; the 3D model still has to reproduce the parts shown in it. Once those are done, we have to see whether the phone can run it. Give an assistant the task “make a good-looking ship,” and it can return something that looks good from a particular angle. Name the seats and glass canopy explicitly, and there is something definite to check next. Several tools can already make models. I still have to decide which one to use at each step, and exactly what is lacking in this version.

Some revisions were outside the game. The first draft of the making-of page used cards with short headings and explanations. They looked too much like AI writing to me, so I asked for whole paragraphs of plain prose instead. The numbers and process were still hard to grasp, so we revised the timeline, then added dragging, zooming, and a default view of the most recent day. Even explaining how the work was done took more than one draft.

When the conversation gets too long, hand it over

The first lead session ran from 16:40 on October 31 to 16:20 on November 2, reaching batch 20. At 17:00 on November 2, a new session took over. The old session first wrote down the progress and next steps, and the new one continued from that handoff. Batch 21 was then completed and installed on my phone at 18:13 that evening. This sequence needs spelling out, lest a long list of results give the impression that all it takes is keeping the same conversation window open.

The details a handoff needs to preserve are rather mundane. It lists the current version and the location of the requirements document, and says whether any tasks are still running. It even records that only one track may use the simulator, and that another session is working on the official website, so its files should be left alone. More to the point, beside the areas where tests have passed, it still lists visuals I need to inspect on the actual phone and sound effects I have not heard. “Installed on the phone” does not tell me whether something sounds good.

If this way of working were moved into a workshop a few hundred years ago, the ledger craftspeople left at a change of shift would probably also have to say which side of an object had been polished and which step remained. That is what a handoff is for: the person who comes next does not need to hear every thought the previous person had while working, but does need to know where to pick up the object in front of them. AI conversations turn over faster than people do, which makes that ledger harder to do without.

Work can continue at night, too. One workflow spent three and a half hours on batches 13 through 15 while I slept. But the overnight work covered batches arranged in advance. Whenever a choice of appearance or a change of direction was needed, the records still left an item waiting for my decision. Looking at those lines of pending work, I suspect what makes “making it alone” misleading is how easily it leaves the judgments that one person has to make out of the picture as well.

How much I used over these few days

The figures below come from a snapshot taken at 14:54 US Eastern time on November 3, 2026. The first model call was at 16:40 on October 31, and the last call included in this tally was at 14:51 on November 3. The project is still underway. These are the figures as of that moment, and they should not be taken as hours I spent sitting continuously at the computer.

A total of 41 workflows ran, containing 131 workflow agents, alongside 3 separate subagents. Codex took on 22 tasks, with 76 threads in the records. They were not all open at once. Concurrency peaked at 15 agents at 16:50 on November 1. The earlier limit of two coding tracks applies to the work that involves editing code and using the simulator together; it does not mean that only two assistants can work on the entire project.

The effort settings were recorded, too. The session state says that the background coding agents used Opus at “high” effort; when the lead session invoked Codex on its own, the specified settings were GPT-6 Astra with ultra effort. This tells us only what was explicitly written in the records. It does not let us infer that every past call used the same setting. Other models were used as well, after all, and not every task involved writing code.

Altogether, there were 11,816 model calls, totaling $1,342.33 at API list prices. Jimeng and Tripo credits are not included. This amount accounts for the model usage in this round of development, not the full cost of finishing the game.

Tokens are the units used to measure what a model reads and writes. This time, there were 58,984,950 fresh input tokens, 2,622,641,817 cached input tokens, and 10,774,948 output tokens, for a total of 2,692,401,715 tokens. The total looks a little startling at first, but most of it consists of rereading earlier content at a lower unit price. For the code, documents, and replies actually written, the output figure is the one to look at. Treating all those two billion-plus tokens as newly written text would be far off the mark.

Broken down by model, Claude Opus 5.5 was called 8,561 times, with 8,931,631 output tokens and 2,332,009,241 cached input tokens, amounting to $946.56. This was the model used by the lead session and many of the workflows.

GPT-6 Astra was called 2,743 times, with 1,660,019 output tokens and 248,203,520 cached input tokens, amounting to $389.99. The source records name it repeatedly in connection with the parallel tasks assigned to Codex earlier.

The other two models saw less use. GPT-6.1 Sol had 185 calls, with 103,915 output tokens and 11,487,616 cached input tokens, amounting to $3.52; GPT-6.1 Terra had 327 calls, with 79,383 output tokens and 30,941,440 cached input tokens, amounting to $2.25. The amounts for each model retain the original figures from the snapshot; their sum is $0.01 below the total.

I am not particularly inclined to turn that total into “how many programmers it replaced.” It includes the cost of repeated reading, as well as the calls spent remaking the same ship after I changed my mind. My own time is absent from this account. What it can answer is how much work the models did over these few days. How many of those attempts might have been avoided is something this tally cannot yet tell me.

A few things still need a look

As of this record, batch 21 is already on my phone, the new ships are still being swapped in, and a ring-shaped space station is being remade. The handoff also leaves one judgment open: do the drifting nebula and twinkling bright stars look “alive,” or merely “wobbly”? The two words are not far apart, but even written on a task list, the question still has to wait for the next playtest.

I will leave a note of it for now. Once the new version is installed, I can just pick up the phone and have another look.

Writing log: Codex wrote this article on 2026-11-03 from 15:47 to 15:56 (US Eastern). The main thread used GPT-6 Astra (gpt-6-astra) with ultra reasoning effort. It independently assigned 3 subthreads: the two that checked the process records and reviewed the writing style used GPT-5.6 Sol (high effort), and the one that verified usage used GPT-5.6 Luna (medium effort). These 4 threads together read 3,013,851 tokens (including 2,797,696 cached input tokens) and produced 34,991 output tokens (including 12,580 reasoning tokens). Claude Code (Claude Opus 5.5) had prepared the source material beforehand; that work is not included in these figures.

Translation log: translated from the Chinese original by Codex on 2026-11-03, 17:37–17:40 (US Eastern). Main thread GPT-6 Astra (gpt-6-astra), reasoning effort ultra; it spawned 1 sub-thread: 1 on GPT-6 Astra (effort ultra). Together they read 469,241 tokens (432,256 of them from cache) and wrote 11,354 (3,117 of them reasoning).