I published Start the Chain: My Three-Agent Setup Is Now One Command, a follow-up to the main agent post. The main agent, secondary and worker setup is now the agent-chain skill in tmux-agents, started with one command, and the post covers what changed with a week of real use and how projects talk to each other. It also covers what happens after a restart: tmux-main-sequence brings back a chain for every project, and /resume brings back the conversations that matter.
The main agent, secondary and worker setup I pieced together by hand is now
built into tmux-agents. One command starts the chain, a script starts one for
every project after a reboot, and /resume brings back the conversations.
I published How To Move Fast and NOT Break Things with AI, about the point where using an agent's name as its id stopped fitting tmux-agents. It covers the move to real ids in progress for v1.9.0, and the tests, decision records and release rules that grew out of real use. The lesson is to prototype fast, then add structure where the problems show up and leave guard rails for the next agent.
Move fast with AI, and add proper engineering when real usage shows you
need it. For tmux-agents, that meant letting each agent's name double as
its id, until it couldn't, and then adding real ids and guard rails so
the agents and I don't repeat the mistake.
I published Messy Chat with Your Agents? You Just Need One More. Really., about splitting the Claude agent I talk to from the one coordinating work on my Stone Age remake. With tmux-agents, the new main agent has one peer: the coordinator, which handles the main Codex agent and its sub-agents. The post shows the setup before and after, why my conversation got quieter, and the extra hand-off that comes with it.
I published I Gave My Coding Agents a Shared Worktree Pool, about the worktrees Claude and Codex left behind while I was building my Stone Age remake. I run those agents through tmux-agents, which I shipped the day before. I replaced fresh checkouts with reusable slots and shared asset folders, then made a general Python version available as a gist. The post covers the lease rules, the disk cleanup that prompted them, and what I have and haven't tested yet.
I published Your Sub-Agents Shouldn't Disappear: Meet tmux-agents, the introduction to tmux-agents that my last two posts kept pointing back to. It covers why I wanted visible sub-agent sessions, how I use them on my game and this blog, and how to try the tool. I also wrote down a few of the design choices and the limits I'm still working through.
With up to ten agents working on one project, the Claude agent I talked to
was also juggling replies, merges and servers, and I kept waiting for my
turn. The fix was one more pane: a main agent whose only job is to talk to
me, while the old one became a coordinator.
Built-in sub-agents hand you a summary and the work behind it is gone.
tmux-agents gives every delegated task its own Claude or Codex session in
a tmux pane instead, so you can watch it, step in, and pick its
conversation up later.
Claude, Codex and their sub-agents each got their own git worktree, and my
disk quietly filled up with copies of an 8GB game project. The fix was a
small script that makes agents borrow worktrees from a shared pool instead
of creating new ones.
I published Two Small Wins That Turned Out to Be the Same Win, about moving my resume pipeline onto a Maestri canvas, teaching it to enforce its own two-page limit, and experimenting with local dictation. They looked like separate improvements until I realised each one removed the same mechanical tax between having an idea and acting on it.
Moving a resume pipeline onto Maestri, teaching it to enforce its own
two-page limit, and trying local dictation apps all removed the same thing:
the mechanical tax between having an idea and acting on it.
I keep staring at the new dotfiles project card image, generated by GPT, and getting a little mind-blown. Not only is every bit of text actually real text rather than the usual AI gibberish, the content itself coheres: the Ghostty window on the left shows plausible git aliases, the tmux pane in the middle has a believable folder listing, a git log, and a btop-style stats block, and the Emacs frame on the right has elisp in init.el and YAML in config.yml that kinda parse as real config.
And on top of that, Ghostty, tmux, and Emacs are exactly the tools I actually use, even if I haven't reached for those particular git aliases in a long, long time.
I published My AI-Assisted Terminal Setup: Subspace Emacs and a Tmux Layout Shortcut, the fuller write-up that ties together the tmux 70/20/10 layout and the move off Spacemacs into Subspace Emacs. It covers how Claude and Codex split the work between research and implementation, the tmux-as-TDD-harness approach that unblocked the layout binding, and the tmux/tmux#1839 discovery that finally let swap-pane preserve zoom state. This supersedes the two narrower notes from earlier today.
Two projects in one: a lightweight Emacs config I actually own (Subspace Emacs), and a tmux 70/20/10 vertical layout I can summon and reshape with a single keystroke. Built collaboratively with Claude and Codex.
Published Where Do Codex's Cached Tokens Come From?, a note explaining why Codex can report millions of cached tokens after a run even when the actual prompt context is much smaller. The useful bit is that Codex's append-only agent loop keeps earlier messages as an exact stable prefix, so cache hits accumulate across repeated model calls in the same session.
It uses ProjectSpire as the working example: instructions as project memory, plans for intent, Captain Logs for collaboration taste, devlogs for technical history, and skills or workflows for repeated mechanical steps.
The bottleneck isn't the model. It's whether your repo can explain itself to a fresh agent. Here's how I'm building AgentOS, a project environment that gets smarter the more it's used.
After a few weeks working on ProjectSpire with Codex, I’m leaning toward it as my default for software engineering projects. The main frustration has been hitting the Pro account limit; otherwise the quality has been good, the interaction feels responsive, and the output gives me instant feedback while it works. Claude Code still feels more like a black box to me: it can disappear into minutes of research and thinking on its own, and the effective limit feels lower. That tradeoff matters, because for this kind of project I want a tight engineering loop more than a long silent reasoning pass.
I’ve been working on ProjectSpire’s iOS app (codename: Neow’s Cafe) in NicholasClooney/ProjectSpire as a 1:1 Slay the Spire 2 card library, and the useful part is not just the filtering UI and refactor cleanup, but the way I’m trying to work with AI.
I get better results when I lay down the foundations myself first, especially around quality, guard rails, and how the data is modeled, and then let AI work inside that framework instead of asking it to define the framework for me. It also helps a lot when I have AI propose higher-level API or contract changes before it starts making edits.
The useful part is not just the snippets themselves, but that AI agents researched the best practices, produced the example code, organized the project, and left me with a runnable playground where I can compare equal-width stacks, GeometryReader, PreferenceKey, and some surprisingly similar results against my actual needs.
I published The Brain That Grew — Then Shrunk: What I Just Discovered, a long-form note that starts from a Cleo Abram YouTube Short and then follows the research on human brain evolution, the unexpected Holocene shrinkage, and the idea that culture may have taken over part of the cognitive load. It is the kind of rabbit hole post I like writing here: one short video, a lot of reading, and a sharper takeaway than I expected.
A look at the long rise of human brain size, the surprising shrinkage that followed, and why the brain may have started delegating part of the load to culture.
I published The Confident Lie: What AI Got Wrong About @ViewBuilder, a SwiftUI debugging note that came out of the ProjectSpire card view work. It captures a small but useful lesson: body gets @ViewBuilder from the View protocol, but a custom computed some View property needs the annotation explicitly if I want an if without an else. The compiler was right, the AI was overconfident, and now the mistake is written down somewhere I can find again.
A real SwiftUI debugging note about optional views, overconfident AI advice, and why @ViewBuilder is inherited by body but not by your own computed view properties.
Published The Accelerated Speed of Creation, a reflection on how much faster the path from thought to shipped artifact has become with coding agents handling the translation layer around writing, blog workflow, and routine Git operations. I also kept the earlier Encoding My Blog Workflow for Coding Agents draft as a note rather than a post, because it was useful and concrete but still did not meet my standard for what the real piece needed to be.
This past week I shipped across code and writing at a pace that would have felt unrealistic before AI. The surprising part was that it did not feel frantic; it felt like less friction between thought and artifact. It truly feels like working at warp speed, 😜.
Look at this. This is what I have shipped so far in a single week and growing (full list here):
A preserved draft that did not meet my standard for a full post. I'm keeping it here as a record of something useful and concrete that still missed the cut on human judgment.
I published Smart AI Token Consumption as a note on matching model choice to task complexity instead of defaulting to the biggest model. It captures the split I keep using in practice: light models for mechanical work, stronger reasoning only when the problem actually needs it.
A practical split between light and heavy models: use the smallest capable model for mechanical work, and reserve stronger reasoning for hard engineering problems.
I published The Limits of AI and Where Humans Shine — a devlog about a tiny timeline sorting bug that turned into a useful comparison between AI confidence, runtime verification, and human judgement. It follows the fix from plausible-but-wrong timestamp changes to a quoted-date guard that keeps the timeline honest.
I hit a bug that looked too small to be interesting: entries on my timeline page were not sorted correctly within the same day.
The page had a date, a time, and a custom Eleventy collection sort. That sounds like the whole problem space. Sort by date plus time, reverse the collection for newest first, done. Instead, April 12 was rendering in a strange order: 00:01, 10:11, 22:16, 15:49, 22:20.
Published What's Worth Keeping: On Humanness in the Age of AI — a post on what I've been thinking about since attending a thought experiment session on AI and skill erosion. It's about the parts of humanness I think are genuinely worth protecting — junior skill-building, critical thinking, forming a view before outsourcing it — and what I actually try to do in my own daily use of AI tools.
A reflection on what AI might erode if we let convenience replace judgment: junior skill-building, critical thinking, and the slower human process of forming a view before outsourcing it.
I've been building a habit-logging iOS app called ProjectDawn. Not because the App Store needs another habit tracker, but because I wanted a personal project that was genuinely mine and open source, and a project that can answer this openly: what does it feel like to build a real, modular, native iOS app with AI as a primary collaborator?
This post is part personal log, part technical retrospective. It covers the tools I used, what surprised me, where the AI fell flat, and the biggest shifts in how I think about building things now.
I’ve had the Umami + Ansible post in my head for ages, but it touched three different repositories and a whole bunch of code snippets. Totally doable, but undeniably tedious — which is why it kept slipping down the backlog. You can read the finished article here: Private Analytics With Umami, Docker Compose, and Ansible.
The idea that finally nudged it forward was simple: why not let GPT (Codex) do the heavy lifting while I steer?
For years, I thought of coding as something tied to my desk — Mac in front of me, full keyboard, full IDE. But recently, I found myself dreaming: what if I could carry my entire creative coding studio in my pocket? Not just SSH access, but a true AI-assisted environment where I could code, commit, and preview my projects anywhere.
This blog is half technical walkthrough, half personal reflection. It’s the story of how I explored Cloudflare Tunnel, discovered Tailscale, refined my workflow with tmux and iTerm, and ultimately unlocked the freedom of having a fully fledged Mac in my pocket.
Building small websites with GPT-5 Codex turned out to be less about typing code and more about collaboration. From crude sketches to polished sites, the model took on the heavy lifting while I guided direction and design.
Along the way I discovered both the joy of fast iteration and the limits of relying on an AI partner. These projects became less about the sites themselves and more about exploring a new style of programming — conversational, creative, and sometimes flawed, but always eye-opening.
Last month, my girlfriend mentioned she needed a sleek portfolio site, and I realized I’d been meaning to start a personal tech blog.
I wanted something lightweight—easy to spin up and even easier to tweak. So I dove in: building a small 11ty + Tachyons site from scratch, pushing every iteration live in under a minute, and watching her face light up with each update even though she’s halfway across the country.