Tuesday evening. Two terminal windows open on the same machine.
In one, I was working through Milestone 1 of a JavaScript curriculum: filter a list, copy an object, write a function that does what I say it will do. The kind of work where the feedback loop is tight and the mistakes are instructive. I peeked at zero solution sets.
In the other, an 11-unit autonomous overnight slate was running: built, validated, committed, and staging its own morning review while I was spelling out .filter() syntax.
Neither lane touched the other. Both finished.
i.The division was the point
I want to be precise about what happened that night, because the easy read is “I multitasked” and the accurate read is something different.
I didn’t multitask. I was doing one thing in one terminal. The system was doing a different thing in a different terminal. Those are not the same activity running in parallel; they are two distinct actors, each fully inside their own lane.
The fleet wasn’t watching over my shoulder while I learned. I wasn’t supervising the fleet while it shipped. The handoff had happened hours earlier, the plan was locked, the criteria were clear, and the system ran without needing me for anything until morning review.
That clean separation is what made the evening work. The human lane stayed human. The system lane stayed system.
ii.What the fleet ran
Eleven units across the overnight slate: build work, validation passes, commits, a morning review queue prepped for 7 AM.
Each unit had a clear definition of done. Each one wrote its own evidence to the queue before the next launched. The adversary ran on the outputs. The pathspec-limited commits kept the interactive session’s work out of the run’s lane.
By the time I was done with JavaScript exercises, the other lane had cleared a sprint’s worth of backlog and filed the summaries where I could read them at breakfast.
iii.What I learned at the keyboard
The JavaScript work was deliberate. A learning arc with a deadline, hands on the keyboard, no ghostwritten code. The pre-staged system absorbed the slow parts, the lookup friction, the “wait, which method does what” pauses, and I moved through five exercises without peeking at solutions once.
The milestone held. The system’s evidence of that is in the learning log.
iv.What this arrangement actually feels like
I’ve tried to describe this to people and the usual frame they reach for is leverage. “You’re using AI to multiply what you can do.” That’s true but it misses something.
The more accurate frame is division of labor with a very unusual division. Not “I do the thinking and the AI does the execution.” Not “I supervise and it runs.” On that Tuesday night, the division was: I did the learning that only a human can do for themselves, and the system did the shipping that didn’t need me present.
Each lane was complete in itself. Neither was a support function for the other.
That’s what working with an AI platform actually looks like on a Tuesday night. Not AI assisting human. Two actors, two lanes, same evening, both real.
Morning review had a full slate waiting. The JavaScript session had a logged milestone.
Both happened. Neither borrowed from the other.
Drafted with Bishop, my AI partner. Words picked, edited, and approved by me.
Drafted with Bishop, my AI partner.
Words picked, edited, and approved by me.
Model provenance: Claude Code (Claude Opus and Sonnet)