How I work with AI tools

I’ve built a stupid amount of stuff with AI tools over the last few months. The list on the left is most of it (on a phone it’s tucked under “stuff” at the top), plus an increasingly ridiculous homelab.

My side of the process is still simple. I talk until the shape of an idea shows up, dump it into a plan, and start throwing work at agents faster than they can finish it. Underneath that is now a small operations shop: several models, worktrees, directory cards, decisions, hooks, running software the agents can inspect, and files that let a new session continue without replaying my life story.

How I got here

This page is about LLMs on purpose. I did a decent amount of playing with Stable Diffusion when it first came out, but that was its own rabbit hole and it didn’t change how I work.

The coding side started in Cursor. I’d been using Claude and other models there for a while, and the loop was exactly what you’d picture: me in the editor with tab-complete and a chat sidebar.

By December the buzz around Claude Code had gotten loud enough that I couldn’t ignore it anymore. I had a Hawaii vacation coming up, so I set up Tailscale and a tunnel to my dev box and ran an experiment: could I build a game from the beach without looking at the screen all the time. That’s how texting_of_isaac happened, a TUI roguelike in the vein of The Binding of Isaac, prompted from a phone (first commit January 13, typed somewhere near an ocean). The loop inverted on that beach: I was reading descriptions of what the code did instead of the diff.

I came back from vacation and almost immediately bought a Mac mini, right before the whole openclaw craze kicked off. Of course I set it up. And I was pretty blown away at first, up until the maintenance became the hobby: every update broke something, and I was the one holding the screwdriver. Meanwhile Claude Code was shipping most of what I used openclaw for, connectors to Discord, Telegram, and WhatsApp were getting easier, and there was that stretch of uncertainty about whether account tokens in third-party harnesses would get you banned. I didn’t want to find out with mine, so I let openclaw die on the vine.

Hermes got a turn in between, briefly. It left so little impression that I mostly know it happened from my own logs. By March the company I work for began adopting Claude Code, and I hit the ground running because I’d been living in it for months. Somewhere in there I helped a friend port a roughly 15-year-old PHP/MySQL codebase to modern React with Vite in an afternoon.

The record on this desktop starts in May, and it starts humble: Claude as a Linux tech. Sorting ROMs, recovering a dead Maxtor drive from 2001, figuring out why Steam was so laggy. June brought the first real builds here (the BTC recovery tooling and Rat Run), and 95 percent of that month’s commits already carried a Claude co-author trailer. Then a 22-day gap, and then July 5: not a gradual ramp, a step change. A 26-day unbroken streak, a 7x jump in prompts month over month, twelve new repos, and 1,388 commits in one month, with the tooling arriving all at once in the first week (background tasks, subagent fan-outs, workflows, hooks, the first skills).

In July I also gave OpenAI a real shot again, around Sol 5.6, and was pleasantly surprised: it’s good at coding now. The first Codex session on this machine was July 9 (its opening assignment was a full feature workload in a fresh worktree, with a note that this was its opportunity to impress me), and there have been 465 since, mostly pointed at pvc-builder. That made the shop multi-model.

Late July was the subagent peak: 318 subagent sessions in one 48-hour Authorbot push, with subagent transcripts outnumbering main sessions two to one on disk. It was also the pruning. The same week, I turned off half my plugins and deleted a multi-agent chat layer I’d built earlier in the month. Build the machinery, then throw out the machinery that didn’t earn its place. By August the work had left the terminal entirely: the biggest thread of the month is a music video, driven through ComfyUI, hosted video APIs, and DaVinci Resolve over MCP. The current version of the loop is what the rest of this post describes.

It starts as a conversation

Before any code exists, the project is usually a chat. Riglab began as a claude.ai conversation titled “Linkage simulator for wearable puppet prototype,” where I opened with:

a small web app that I can use to quickly prototype and mechanically simulate linkages for a physical wearable pvc articulated pseudo-marrionette attached to a pack frame.

That’s me thinking out loud until something useful appears.

Sometimes the raw material is somebody else’s words. I’ll paste a whole conversation with a friend, or a rambling ChatGPT thread, and ask for structure. The goal is the same every time: get the idea out of my head and into text I can inspect.

One hard-SF brainstorm grew into a cosmology, machine design, addiction mechanism, plot, and ending. I asked for a development brief and a benchmark prompt with our answer removed. That material became The Causal Projector, a book in progress on the platform I built because apparently writing the book wasn’t enough of a side project.

Then I make it durable

Once I roughly know what I want, I open with a wall of text. Bad grammar, unfinished sentences, all the important constraints mixed together. Here’s the real opening prompt for pvc-builder, typos and all:

This project is going to be complementary to riglab (in the parent dir), but geared towards FAST experimentation, development, and visual simplicity. It will be be a web app that acts as a 3d-first PCV creation design studio. […] Pull a library of common fittings from somewhere like home depot or mcmaster, or if you can’t ask me to do it for you.

“PCV.” “be be.” Fine. The prompt still contains the product, constraints, judgment calls, and an instruction to ask instead of making shit up. Turns out grammar was never the point. The nuance was, and a brain dump carries it fine. Then I have the agent turn it into a plan with goals, non-goals, phases, and acceptance criteria. From there, the plan is the source of truth. My rambling did its job and can retire.

What survives becomes files:

the plan says what I’m building;
the decision log says why it has this shape;
directory cards say where the code lives and what must stay true;
findings record investigations that produced no code;
handoffs separate verified state from unfinished work; and
tests and hooks enforce anything too important to leave to memory.

I also separate confirmed decisions from recommended defaults. An assistant’s decent guess shouldn’t drift into something I supposedly approved. When a discovery pass ends, I often turn it into a clean brief for another agent: the mental model, target changes, verification commands, and the files it shouldn’t touch.

Literal cross-session memory matters less than I expected. Most of my durable memory is Markdown and Git. I changed agent stacks three times on one machine in six months (openclaw, then Hermes, then Claude Code) without changing the basic process. The tool changed and the repository didn’t care.

Split the work, isolate the files

Once a project is clear enough to divide, I stop treating the model as one assistant. One agent can investigate, another can build, and a third can review the result. Sometimes I ask several to try the same uncertain feature and keep the version that sucks least.

Git worktrees are the basic isolation tool. On one project, a scan found 56 agent-created worktree branches over about four months, including days when three to seven appeared at once. In pvc-builder, a claim board says which files each agent owns and names the choke points that need to be handled one at a time. Schema migrations, the editor action layer, and scene composition are bad places for two enthusiastic robots to improvise together.

The repository does the job people expect a shared chat log to do. Agents don’t need access to one another’s hidden reasoning. They need current plans, scoped ownership, handoffs that admit what isn’t finished, and a record of what changed. I wrote up that setup in Three coding agents, one workspace.

Collisions still happen. I’ve made commits that amount to “fix the thing the subagent overwrote.” Worktrees and claims don’t make that impossible. They make it obvious before two agents combine their work into one exciting pile of garbage.

The cast

The division of labor sorted itself out through use. My mid-July assessment, verbatim from the logs: “Grok is cheap, Sol is super smart but cautious and better at prose than code (sorry), and Fable is the coding master but slow as hell.” That snap judgment aged into structure. Claude owns most of the building. Codex started as a second primary coder and ran repos solo overnight, then drifted somewhere I didn’t predict: it became the novel’s co-author, and by early August its median prompt from me was three characters, because it generates the options and I pick from menus. On one memorable day in July, Sol beat Fable to finishing the book draft.

pvc-builder is where the differences showed up most clearly. Opus took it from an empty scaffold to a deployed 3D editor in under a day off a plan I wrote, for hundreds of dollars less than Fable’s Riglab. Codex then reviewed the working app cold and landed a 43-file reorganization as one reviewable branch. Fable went after the seams (the interaction bugs and geometry cases nobody would think to put in a plan) and burned 36 percent of a freshly reset allowance in about three hours doing it. In a bit over two days the repo hit v0.3.13 with 126 commits, and I remained the scheduler, product owner, QA department, and guy with increasingly specific opinions about hot PVC.

I never let them finish a thought

Once something works, I queue the next task before the first one ends. Then another. Then a bug I noticed. Then “actually, undo the thing from three messages ago.” Across three machines and 132 sessions, I sent a new instruction while the model was still working 700 times.

I’m glad these things aren’t conscious. I would be an absolute monster to work for. There’s no “when you get a second.” I keep dropping work on the pile while the model is chewing the last bite. A human coworker would rightfully throw me into traffic. The model says “on it” and carries on.

The branch history looks calmer than the conversation. On one machine, interruptions showed up in only three of 19 sampled sessions, and half had gaps of two hours or more because I leave agent work running and go do something else. In Git it looks less like frantic pair programming and more like several half-finished pull requests sitting on benches around the room.

What the logs say about me

For the latest revision of this post I had agents mine the session logs here (1,704 Claude prompts back to May, 1,212 for Codex) to check the story against the data, and the data had notes.

My prompts never changed. Median prompt length is flat from May to August (around 58 characters), short prompts hold steady, and the rare wall of text was always rare. The scaffolding around each sentence grew twentyfold; the sentences didn’t. Whatever this workflow is, it isn’t me learning to write better prompts.

The logs also corrected my self-image. I described myself above as constantly interrupting, and across three machines that was true, but on this box I now queue instead: 1,176 uses of the prompt queue against 68 actual interruptions. Same impatience, more polite plumbing. And for all the coordination writing on this site, I have typed the word “worktree” exactly once. The agents create the worktrees; I just benefit from the isolation.

I almost never ask for reviews either. Reviews happen constantly (they’re 30 percent of all Codex sessions), but the harness triggers them automatically on diffs.

Let the software point at itself

Text is a lousy way to explain some bugs. “That pipe moves wrong when I do this” can produce an hour of careful tests for a different pipe doing a different wrong thing.

pvc-builder has a development-only bridge between the coding agent and my browser. The agent can inspect the document, selection, camera, editor state, and simulation, then use the same actions as the interface. I select the broken object and tell it to look. That removes a translation step that was both expensive and unreliable.

Tests are still the durable gate, but live state is evidence. The agent can observe the failure I mean and then write the regression test. Human pointing supplies the bit of information the suite doesn’t have yet.

The trick is spreading: vibecad wires chat straight into its 3D canvas, and the music-video edit drives DaVinci Resolve over MCP, with an agent rating takes and landing cuts on beat.

The same idea works outside a browser. My homelab runs a Dockerized stack with ESP32 microphones, local speech recognition, Home Assistant, and house speakers. Larger hosted models plan the action. Local services keep the audio, voice cloning, and screen vision on my hardware. The answer comes back in a Werner Herzog voice, often with a comment about the futility of existence or the stunning idiocy of chickens.

Each service owns a small set of tools and local details. The planning model doesn’t need a dissertation on my network every time I ask it to turn off the kitchen lights.

It isn’t only software

I use the same loop for music. Suno Experiments became an album, then a version-control problem, then Motif Forge, then a local music lab that is now almost a replacement for the parts of Suno I care about. Suno is good at generating variations and terrible at remembering why generation 47 mattered. The durable work (lyrics, motifs, lineage, and production notes) lives in the repository, along with the skills and hooks that maintain it.

I use agents for MIDI routing, musical hooks, light control, hardware research, and, on one memorable night, the predicative justification of Mahlo universes. The subject changes. The loop doesn’t: talk until something takes shape, write down the state, split the work, inspect the result, and keep what holds up.

Authorbot is the same idea applied to writing. It puts comments, votes, work claims, revisions, and publication around a Git repository, then gives humans and agents the same API. It doesn’t write. It stops the writing process from dissolving into chats and mystery files.

What I still do

The agents type most of the code. On my Mac mini, about 74 percent of surviving commits had a Claude co-author trailer, and this desktop adds over 800 more; that’s probably still low, since squash merges erase much of the attribution elsewhere. Pretending I personally wrote every line would be silly.

I provide direction, source material, constraints, taste, and the final call. I decide which approach is worth trying, which agent gets it, when three versions should compete, and which one survives. I resolve real ambiguity. I do live checks that source code can’t answer. I stop beautiful implementations built on a bad premise.

I also decide when a rule should stop being advice. Important operations are blocked by hooks until I approve them. Review requests follow a template. Findings have to say whether a claim came from code or from a live test nobody actually ran. Writing “remember to ask” into a file is just prose, whereas a hook that refuses the action is a process.

The models provide patience, recall, and typing speed I don’t have. They don’t take responsibility. One session contained 179 consecutive agent actions without a message from me. Responsibility didn’t transfer during that streak.

Keeping the output mine

The voice is the part I’ve worked hardest to keep. I got tired of deleting the same synthetic tells from every draft (the em dashes, the fake gravitas, the tidy three-part lists), so I had an agent mine my own writing instead of my memory of it: prompt history, sent email back to 2009, and an export of my entire Messages database, 64,000-odd texts and about half a million words. The instruction was “you don’t have to be nice, just accurate.”

Its first read got me wrong in an instructive way: it decided I was a deliberate minimalist who saves punctuation for humans. The correction (typing to an agent is speech through a keyboard, not writing) reshaped the whole project into one rule: keep the fingerprint, drop the shorthand. The findings that survived were essentially zero deliberate em dashes across twenty years of writing, parentheses and the Oxford comma everywhere, “stuff” beating “thing” as my filler of choice, and a measured comedy trade surplus of 940 laughs in my favor, which I consider settled science.

That guide became a skill installed in both harnesses, and the models draft in that voice now, including on this post. My wife still catches the word echoes. I keep feeding the skill corrections as they annoy me, which is its own kind of maintenance. The full self-audit, including what half a million words of texts revealed about my spelling, is in How I taught my agents to write like me.

What breaks

This machinery isn’t tidy.

Agents clobber changes when ownership is vague.
Directory cards rot unless every relevant change updates them.
Authentication expires and unattended jobs quietly die. One old orchestrator ended with every scheduled task failing on the same stale token.
I build more coordination machinery than I end up using.
The best models eat allowances and money at a spectacular rate. The one budget note in 1,704 prompts, kept word for word: “don’t be smug about how good the workflows are. I can’t afford to use them all the time.”
Generated work gets hard to organize. My Suno account is an experiment graveyard with a search box.
Important projects get plans, tests, hooks, and clean history. Experiments get a directory containing three days of work and optimism.

How much rigor something gets tracks how much I care about it. The flagship work gets guardrails. The rest accumulates abandoned scaffolding and services that are “configured” in the same sense that an empty refrigerator is prepared for dinner.

Coordination is where the work is

I think the most useful work left in agent systems is the boring layer between people, agents, repositories, and running software, not another model wrapper.

Chat history is expensive, lossy, and stuck inside one tool, while plain files travel well and then quietly go stale. Git records what changed, though not which old decision still matters. And the running software knows its own state perfectly well; it just can’t explain any of it to an external worker.

The pieces I keep rebuilding are:

cheap channels so agents can say what they’re doing;
claims or leases so two of them don’t edit the same file;
project notes scoped tightly enough to survive a model change;
some way to search old decisions, failures, and handoffs;
a live connection to the running application, which is the one people skip; and
a hard split between what was observed, what I decided, and what an agent guessed.

pvc-builder has crude versions of these. Authorbot has a more formal version for books. My homelab does the same thing across services. None is general, but each saves enough time to make the pattern hard to ignore.

Being a generalist finally paid off

I get good results from these tools because I’m a generalist, not because I’m a better programmer. Steering an AI rewards the generalist’s habits.

I’m almost 43. I’ve spent those years poking at an absurd range of stuff. I ran a hardware-recycling startup in Alaska after pulling an ancient function generator from the dump, opening it, and finding nixie tubes and gold. I took apart laser printers old enough to use helium-neon tubes and castoffs from the NOVA project that ended up at the HIPAS observatory near Fairbanks and got auctioned off for a song. I taught myself to refine gold from scrap electronics. I posted flyers at transfer stations so dumpster divers would sell me their hauls, built things from the pile, and sold power transistors and scintillation crystals to collectors on eBay.

I’ve written code in dozens of languages and don’t remember any one of them well enough to call myself an expert. That used to feel like a liability. Jack of all trades, master of none.

It turned out to be the whole advantage. The model already types faster and remembers more APIs than I ever will. My job is knowing what to ask, smelling when an approach is going wrong, and dragging experience and taste from ten unrelated subjects into one problem. Twenty-odd years of taking things apart, and of never quite believing anything is too hard to tackle, is pretty good preparation for this.

Six months ago I worried AI would take my job. Now I think it rewards the exact scattered generalist I already was.

Claude agrees, for the record. I asked. Claude also calls my half-baked ideas “genuinely great” several times a day, so an AI endorsing my theory about why I’m good at AI isn’t exactly a valid datapoint. These things lean sycophantic and you learn to discount it. I’m keeping that particular bit of flattery anyway.

How this post got made

The first version used the method to document itself. I gave an agent logs from three machines and a claude.ai export. It mined 132 sessions, which is where the 700 interruptions came from.

For the next revision, agents on my machines audited session logs, Git history, worktrees, and whatever hooks and skills were installed at the time. A third agent combined the sanitized reports with the pvc-builder history, book brainstorm, music posts, and my corrections (which included kicking an abandoned project out of the draft entirely).

This pass happened after I finished Authorbot. I rewrote the whole thing again because the earlier version sounded more like an unusually polite quarterly report than me.

The site is part of the loop now: a skill scans my repos and session logs, updates the project pages in the left rail, and drafts the weekly posts for my review. Those stay frozen once published. This post is the one exception, the piece I keep revising as the process changes, and the latest revision came from agents reading the logs of me directing agents, which is either dogfooding or an ouroboros, depending on your mood.