Four years of coding with AI

The routine was old and familiar. I read the docs, wrote the code, ran it and searched for whatever error came back. The browser was already part of the work, though nobody would have called it a collaborator.

At first I used it as a better search box, for explaining an error, describing an API or writing a regex. Whatever it said still had to be read, weighed and retyped by hand.

It was the first real change in how I worked. The chat became a second editor, one without access to any files, and every round trip was manual. The model knew only what I had thought to paste.

Both cited their sources more carefully than ChatGPT did, and both were worse at holding a conversation. They were good enough to try and not quite good enough to pay for.

Searching and asking became a single gesture. The browser stopped being a separate stop on the way to an answer.

It left one less tool to keep track of. The copy-and-paste habit hadn't died, though. It was waiting for a model good enough to bring it back.

Completions shifted the unit of work from a line to a sketch. I would write a signature and a comment, then accept or reject what appeared. There were no prompts and no pasting, only typing with a faster echo.

Local models were slower and less capable, but they were always on and cost nothing. They became my playground for prompts, evaluations and tooling experiments.

Tending that zoo of local services by hand had stopped scaling, so I turned the tooling into a product that starts the whole stack preconfigured. It later collected a few thousand stars.

It was the first real coding agent I ran, and it edited files directly. But the loop lived outside the editor, and reviewing its diffs took about as long as writing the code myself.

An agent proposed edits from a chat panel next to the code. The tools had simply gotten ahead of the models I could afford to run through them.

Entire files went in and entire files came out. It worked well enough to justify the friction, which is usually the sign that the friction should be automated.

I no longer had to paste anything to ask about my own project. General questions stayed in the browser; specific ones moved next to the code.

For the first time, an agent edited across files inside the editor while I reviewed instead of typing. The clipboard finally went quiet.

Once the machine was reachable from my pocket, the question shifted from which tool to use to which machine to reach. Long runs could continue while I was away from the desk. It was the first of several ways into the setup from the phone.

Parallelism, at that stage, meant windows. Each one had its own agent, its own repository and its own quota, and my job was mostly noticing which one needed me.

The laptop went back to being a laptop. Models, interfaces and other services now ran on a box that is always on and has the memory for larger models.

There were no ports to open and no VPN to babysit. Every machine joined one private network, and the phone became just another node on it.

SSH from the phone lands in a session that outlives the connection. Whatever was running on the devbox is still there after the train comes out of the tunnel.

Everything an agent needed to know about me and my projects had been scattered. lifeos gathered it: notes, a task list, agent definitions and, later, the machines themselves.

The rule was strict: the orchestrator could only delegate and keep the to-do list. Fresh subagents did the actual work, so the manager's judgment didn't degrade as the session grew longer.

That made three levels. DRUG decided what to build and in what order, RUG split each milestone into features, and SWE and QA agents did the work. It was, in effect, a workflow engine with a model at every node.

The whole system lived inside a single editor process on a single machine. When the quota ran out or the window closed, everything stopped.

Claude Code worked from a terminal with the repository as its world, and the editor became a place to read diffs. I retired RUG and DRUG, because the model could now plan and delegate on its own.

Instead of teaching each tool separately, I wrote the know-how down as skills: discipline, bugbash, integration testing, ideate. mi was the smallest harness that could load them.

Agents no longer needed the laptop to be awake. A systemd service on two Linux machines ran OpenCode with four personas, LHE, BUILDER, CRITIC and PLANNER, and took its tasks from dstask.

If OpenCode was a worker, Hermes was a front door, handling Telegram, YouTube uploads and daily summaries of what had happened. For a while the two ran side by side.

Different models were good at different things, and every subscription had a quota. Running several harnesses at once turned the choice of model into a scheduling problem.

With five harnesses running, reading logs by hand had stopped working. tracequest indexed thousands of sessions and later mined 1,200 of them for patterns of failure.

The skill turns a task and a time budget into a loop of subagents, dispatched across Claude Code, Codex, Cursor, Cursor Cloud and Grok. I set the clock, and the agents choose the steps.

The always-on worker had done its job, and the harnesses' command-line tools ran just as well on demand. The task list outlived the daemon that used to read it.

Terminals became sessions that something else could start, stop and read. The board replaced the shell as the place where work is visible.

Each instance keeps its own database, repositories and tasks. The controller talks to them directly over MCP; all that was missing was a way to address them and a health check.

The registry is a JSON file, and the tool is plain Python with nothing to install. Restarts refuse busy hosts, and the sync prunes whatever was removed, so the machines never drift apart.

It is the same fleet-control-center skill that began as an automation on sandbox-av, now running across the whole fleet. My attention goes to goals and irreversible decisions, not to watching.

What changed over four years was less the model than the place where the loop lives: first my hands, then the editor, a terminal, a board and, finally, a fleet.