Tools I Actually Use

No cap, no yap. AI has written all my code for the past 6 months. No more IDE. No VS Code, no Cursor, no ma nothing. Just good ol' TUIs and Claude Code, which definitely has no TUI bugs whatsoever. Yup, I'm not kidding. Coding agents do literally 100% of my coding now. All I do is yap at my computer and code gets written. It's hilarious. It also actually works. It doesn't just work, it fucking flies.

Now for the juicy content: here's the unfiltered recap of the tools that I use every day.

How my day actually works

I wake up, open Agentboard. What's Agentboard, you ask? It's a web based UI wrapper around tmux, and I do all of my work from it. I'll usually have a few Claude Code sessions still running from the night before. I try to work in parallel. Read what Claude wrote, think about it critically with what remains of my slowly atrophying brain, write a prompt, fire it off, switch to the next thing while it works. Waiting for an agent to finish is dead time, and the most efficient use of it is sending another agent a different task. Naturally, the biggest enemy of this workflow is scrolling Twitter.

Which is why during this downtime I immediately open Twitter and start scrolling. I was so chronically online and addicted to doomscrolling Twitter between prompts that I built a Chrome extension I'm quite proud of called Hush Focus. It completely blocks Twitter and YouTube unless I have an active Claude Code or Codex session running. The second an agent finishes and I have nothing running, access gets cut. It also plays a noise every time a session finishes responding.

Now you might think that it's insane and cringe that I had to build software to stop myself from scrolling because I have no self control, and to that I tell you well now all of my dopamine is from wrangling Claude Codes to do my bidding and I'm now a 10x AI engineer™. I credit my success to this one Chrome extension.

The main issue with running many things in parallel is the context switching tax. There's a cost to multi-tasking. If the agents weren't so slow I would iterate on one thing at a time but because it can take 5-10 mins for a single task, I'm forced into this workflow. I'm still getting better at multi-tasking. My reading and comprehension skills are getting faster. But even running just two or three tracks at once is way more productive than the old loop of prompt, wait, stare at terminal, prompt again. And vastly more productive than growing a crop of organic free-range hand-written artisanal human-authored code.

YOLO Mode

For the last 6 months I've also exclusively run Claude Code and Codex in yolo mode. Zero permission restrictions. No sandbox. No approval prompts. No nothin'.

This was the first 10x speedup. Manually approving stuff forces you to stare at the terminal waiting for input. This unlocks autonomy and parallel workstreams. Now before you freak out, I was smart about it. I do this all inside Docker. My setup is open-source and you can find it here: Claude Ting. It has some key useful features. Despite the name, it supports both Claude Code and Codex. The agent container can only see the mounted project folder. Auth is automatic so no relogging every time. You get the speed of YOLO mode without the risk of Claude deleting your home directory.

I've been running this setup since mid-2025. And I've been iterating on it ever since. Before this, I was clicking "approve" on every file edit as if I knew better than the models. I clearly don't, so now I let Jesus take the wheel.

Plus, did I mention every container comes pre-equipped with its own Chromium browser, a virtual display to render it on, and Playwright MCP to control it? That's right my self-contained Claude containers can spin up dev servers and test their own UI work. They can even go rogue and browse the web if they want.

Agentboard

Agentboard is a web UI for tmux. It's not my project but I'm one of the main contributors. This was another huge unlock: terminals in the browser.

Every Claude Code session runs in tmux. Agentboard just puts them all in a browser layout where I can see what each one is doing. When an agent spins up a sub-agent aka another "developer" (more on that later), Agentboard automatically discovers it because it's just another tmux session. I can watch, I can jump in and take over manually, I can kill it. Total visibility, all the time.

I used to use Ghostty for everything but Agentboard is way better than Ghostty for my use case. Sorry Ghostty. The scrolling is not as smooth because it's tmux, but the tradeoff is worth it.

Now here's the magic. Because it's in the browser, I can use it from my phone. I have Tailscale on my laptop, phone, and VPS. So regardless of whether I'm walking my dog, getting a haircut, or sitting on the toilet, as long as my laptop is on, I can do work from my phone. I can manage all of my agents and ssh into all of my servers from Safari.

The bottleneck is just screen size and having a keyboard. Now that work is on my phone too, my brain has no escape. No time for doomscrolling. We have agents to wrangle.

Agents spawning agents

Now you might say Claude Code already has sub-agents. Yes, they work, but you can't see what they're doing and you can't take over if they go off track. So I built the Dev Sessions MCP as part of the Claude Ting repo.

It sounds fancy but it's quite simple. Creating a "developer" just starts a tmux session and runs Claude or Codex in it, with the option for it to be containerized running my custom docker setup, or native to your computer with no container. Yes that's right, Claude in Docker can spawn another Claude outside of Docker and tell it to delete all of my files. The MCP gives your agent 3 main operations: create a new developer, send a message to a developer, and read the last N lines of their output. That's it. Oh and each session gets a random League of Legends champion + role as its ID. So you'll have riven-jg working on your frontend while ahri-mid refactors your API. It's the little things.

But what this enables is nuts. And it works beautifully. My main Claude Code instance becomes a manager. A high-level thinker. After it understands the codebase, I tell it what I want. Once we're on the same page, it figures out the sub-tasks, spins up developers for each one, monitors them, and brings the results together. And because each developer is just tmux, Agentboard picks them all up automatically. I have eyes on everything.

There's a few other patterns I use this for and I have skills for all of them:

• /dev-control - orchestrate tasks by remote-controlling other developers via the MCP
• /architect - similar but using Claude Code's built-in sub-agents
• /handoff - pass the baton to a fresh session when context fills up. Sends the new dev a briefing without losing nuance to compaction

Why do I need /handoff when /compact exists? Well let me tell ya Claude Code's built-in compaction is god-awful. I hate it. It takes way too long to write a simple summary, and the summary is bad. It both includes irrelevant information and also throws away context that matters and the agent gets confused.

My approach with /handoff is different. I don't try to compress the existing session. I just start a new one and have the current agent write a briefing with only the relevant details for what comes next. Because the agent is smart and has all the context, the briefing is perfect every time. The workflow continues like nothing happened. It works really, really well.

Context management is probably the single most annoying part of working with Claude Code right now. The 200k context window is tiny. Just reading all the relevant files and docs puts most of my agents at 100k before they even start working. It's not perfect but sub-agents and handoffs are how I deal with it. I'm still searching for a better solution.

Yapping to my computer

The next biggest speed unlock for my workflow: voice-to-text prompting.

This one's not a secret but speaking is truly way faster than typing. The only downside is I kinda look like an unhinged lunatic when doing it in public. I use NVIDIA's Parakeet speech-to-text models running locally through an open-source app called Handy. Superwhisper? WisprFlow? Absolutely not. Why pay when I have the models at home? Just download the Parakeet model and run it yourself. It's faster, more accurate, and best of all, it's free.

So yeah. Talk to my computer, yap yap yap, the transcription pastes into Claude Code, and code comes out. I don't even bother cleaning up the typos. The AI will understand regardless of how mangled the text is.

The stack

Has this saved me time? An insane amount. I'm a solo dev shipping at a pace that would've needed a team not that long ago.

Has it saved me money? Absolutely not. I pay so much money to Anthropic. I'm personally increasing Anthropic shareholder value. But do I regret it? Hell no. The leverage you get is worth every penny.

Everything here is open source. The only thing stopping you from being a 10x AI engineer is yourself. The hardest part is letting go. Trusting the agent enough to stop hovering over every file edit and just Jesus take the wheel. By Jesus I mean Claude.

And don't get me started on OpenClaw. That's a blog post for another time.

AI has written all my code for the past six months. I don't use an IDE anymore. No VS Code, no Cursor, nothing. Just terminals and Claude Code. It sounds extreme, but it works remarkably well. Here's the full breakdown of what my setup actually looks like.

How my day works

I start each morning by opening Agentboard, a browser-based UI for managing tmux sessions. Usually a few Claude Code sessions are still running from the night before. The core idea is simple: while one agent is working, I'm reviewing another's output or writing the next prompt. Waiting for an agent to finish is dead time, so I try to always have something else in flight.

The downside of this is that downtime between prompts is dangerously tempting. I kept catching myself on Twitter while waiting, so I built a Chrome extension called Hush Focus. It blocks Twitter and YouTube unless I have an active coding session running. When everything finishes, access gets cut. It also plays a notification sound when a session completes so I know to come back.

Running things in parallel has a real context switching cost. If agents responded instantly I'd just work on one thing at a time. But with 5-10 minute waits per task, even two or three parallel tracks is a huge improvement over the old loop of prompt, wait, stare, prompt again.

YOLO mode (safely)

I run Claude Code and Codex with zero permission restrictions. No sandbox, no approval prompts. This was the single biggest speed unlock. Having to manually approve every file edit keeps you glued to the terminal, which kills the whole parallel workflow.

The safety net is Docker. My open-source setup Claude Ting runs each agent in an isolated container. Despite the name, it supports both Claude Code and Codex. The container can only see the mounted project folder, and auth persists automatically so you don't have to re-login every time. Full autonomy without the risk.

I've been running this since mid-2025 and iterating on it ever since. Each container also ships with its own headless Chromium browser, a virtual display, and Playwright MCP to control it. Agents can spin up dev servers and test their own UI changes, or browse the web when they need to look something up.

Agentboard

Agentboard is a web UI for tmux. I'm not the creator but I'm one of the main contributors. The idea is simple: all your terminal sessions, visible in one browser tab.

Every Claude Code session runs in tmux. Agentboard lays them all out so you can see what each one is doing. When an agent spawns a sub-agent, Agentboard picks it up automatically because it's just another tmux session. You can watch, jump in, or kill anything at any time.

The best part: because it's in the browser, it works from anywhere. I run Tailscale on my laptop, phone, and VPS. As long as my laptop is on, I can manage everything from my phone. The only bottleneck is screen size and not having a physical keyboard.

Agents spawning agents

Claude Code has built-in sub-agents, but you can't see what they're doing and you can't take over if they go sideways. So I built the Dev Sessions MCP as part of Claude Ting.

It's simpler than it sounds. Creating a "developer" just starts a tmux session running Claude or Codex, either in a container or natively on your machine. The MCP gives agents three operations: create a developer, send it a message, and read its recent output. Each session gets a randomly generated League of Legends champion + role as its ID (e.g., "riven-jg" or "ahri-mid"), which makes them easy to track.

What this enables is a clean manager-worker pattern. The main Claude Code instance becomes the orchestrator. It understands the task, breaks it into pieces, spins up developers for each one, monitors progress, and pulls the results together. Since everything runs in tmux, Agentboard picks it all up automatically.

I have a few custom skills for different orchestration styles:

• /dev-control - orchestrate tasks by remote-controlling developers through the MCP
• /architect - similar approach but using Claude Code's built-in sub-agents
• /handoff - transfer work to a fresh session when context fills up, with a targeted briefing instead of lossy compression

The /handoff skill is worth highlighting. Claude Code's built-in /compact takes too long and the summaries aren't great. They include irrelevant information while dropping context that matters. My approach skips compression entirely. Instead, the current agent writes a briefing for a fresh session with just the relevant details for what comes next. It works much better.

Context management is honestly the most frustrating part of this whole workflow. The 200k token window sounds like a lot, but just reading the relevant files can eat half of it before real work starts. Sub-agents and handoffs are how I manage it, though I'm still looking for something better.

Voice-to-text prompting

This one is underrated. Speaking is just faster than typing, especially for longer prompts. I use NVIDIA's Parakeet speech-to-text models running locally through an app called Handy. There are paid options like Superwhisper and WisprFlow, but the open-source models are just as good and free. The transcription doesn't have to be perfect either. The AI figures out what you meant regardless.

The stack

Has this made me more productive? By a lot. I'm a solo developer shipping at a pace that would have taken a team not that long ago.

Has it saved me money? Not even close. My Anthropic bill is something I try not to think about. But the leverage is worth it.

Everything here is open source. The biggest barrier to this workflow isn't the tooling. It's learning to trust the agent enough to let it work without hovering over every edit.

I've also been experimenting with OpenClaw, the open-source AI agent that's been going viral. It's become another meaningful part of my workflow, but that deserves its own post.