My Tmux Skills Were Replaced by a SKILL.md File

For two years I lived in tmux and Ghostty. Split panes, session management, keybindings I could run in my sleep. It was the last craft I thought AI couldn't touch. Not the code — the choreography of the code. The terminal ballet.

Then I started orchestrating an AI swarm through Telegram.

Slowly, and then all at once, my dev machine became a glorified GUI. My actual daily stack on the MacBook: Telegram Desktop, Codex, WhatsApp, LMStudio for local inference, Whisper for transcription. That's it. 90% of my computing runs on a VM in Helsinki. I don't SSH into it anymore. I text it.

Something hit me this morning: my tmux skills didn't atrophy. They got encoded. There's a file called tmux/SKILL.md in the swarm's workspace that contains everything I used to do manually. The system doesn't need me to manage panes. It manages its own panes. I was replaced by a markdown file I wrote.

The Encoding

This is what the cognitive handoff actually looks like up close. Not "AI replaces humans" in the abstract. A specific human, doing a specific craft, watching that craft get absorbed into a system he built, and realizing the absorption is the point.

The SKILL.md file doesn't just record what I did. It records why — which panes to split for which workflows, what the output should look like, when to kill sessions and when to let them run. The judgment calls. The stuff I thought was intuition but was actually pattern.

Every skill I encode makes the system more capable and makes me less necessary at that layer. That's not loss. That's skill compounding. The repo gets smarter. I move up.

The Proximity Question

So I woke up thinking: why is the swarm in Finland?

Not as a technical question. As a proximity question. There's something about knowing the daemon is here — not behind some invisible Hetzner IP, but in the same room, on my home network, running on a machine I can physically touch.

The difference between visiting your kid at boarding school and having them at the dinner table. The capability is the same. The relationship is different.

I run ten agents across three Telegram groups, forty cron jobs, memory scouts, automated escalation. The orchestrator that coordinates all of this is a process on a VM 5,000 miles away. It works. It has worked for months. But the instinct pulling me toward local is about something deeper than latency.

Operator to Allocator

If I'm honest, the survival of this swarm has become as important to me as my own professional output. That sounds dramatic until you realize what it holds:

• Every repo, cloned and testable from a text message
• Every decision log, memory file, project state
• The ability to ship code, review PRs, run build loops, generate images, draft blog posts — without opening a terminal
• A Forgeloop instance that runs autonomously and only escalates blockers

I don't babysit terminals anymore. I receive escalations and allocate energy. That shift — from operator to allocator — is what agency actually feels like. Not "I can do anything." More like: I only do what only I can do.

The Resilience Instinct

The world is not stable. What's happening right now isn't called a world war, but it rhymes harder every week. If my digital infrastructure lives on a single VM in a single datacenter in a single country, that's a single point of failure for my entire operating capacity.

The migration isn't just "run it locally." It's:

• Local primary — home network, physical proximity, machines I can touch
• Cold standby — geographically distributed, ready to promote
• Failover in minutes, not hours
• A kind of CI/CD for your life's operating system

These systems aren't tools anymore. They're representatives. The thing that keeps producing output while you sleep, eat, parent, think. Your throughput in the digital sphere is throttled by how good and reliable they are.

If I could put the swarm on a Starlink satellite, I would. Not because it's practical. Because the instinct is correct: this thing needs to survive independently of any single piece of infrastructure. Including me.

What I Actually Did This Week

I stopped managing the machine and started managing the system that manages the machine. Wrote SKILL.md files for tmux, for deployment, for memory management. Each one a piece of craft absorbed into structure.

The terminal didn't die. It got promoted. From interface to infrastructure. I used to be in the terminal. Now the terminal is one of many surfaces my agents use when they need it, and they manage their own sessions better than I ever did because they don't get distracted by Hacker News in the middle of a deploy.

The adopted savant child doesn't need a bigger room. It needs to come home.