Welcome to my corner of the internet! I'm Moses Amani, and recently I started an incredible journey as a software apprentice.
Almost immediately, I was thrown into the deep end of Agentic Workflows. It’s intense, it’s fast, and it demands a totally different approach than the manual "chiseling code line-by-line" I expected. The goal isn't just to write code; it's to orchestrate production.
This is how I built my setup to survive—and thrive—in this new agent-driven landscape.
The Flow Explained
The Central Hub (Me): I sit in the Terminal (using Neovim and tmux). This is my view for architecture and reviewing why changes were made.
The Workhorses (The Closet): Since running 16+ agents on one machine crashes it, I dug out old mini-PCs and connected them (using GL.iNet KVMs). These are headless nodes, each running 4 agents (16 threads total). They are pure Unix executors—perfect for agentic tools.
The Mesh (Tailscale): Crucial piece. Tailscale turns these scattered closet PCs, my development laptop, and even my phone into one private local network, anywhere. I don't punch holes in firewalls or manage complex VPNs. They just connect.
The Orchestra Leader (Herder): tmux isn't enough to manage 16 active streams. I use Herder. It’s team tmux plus notifications. When an agent node finishes its job or needs human intervention, it goes "DING!" (a little bell). I am instantly notified on my dashboard (and phone), ready to make a high-level decision, review a diff, or unblock a task.
Context Review: When an agent pushes code, I use LazyGit or Hunk to review the change. I prefer seeing the surrounding code context (Neovim) rather than just the isolated diff hunk, to ensure it integrates correctly.
👍 The Pros (Why this Setup is Suitable for Me @ Zero One)
This is a high-throughput production environment. We aren't just learning; we are delivering.
Maximized Human Output: When you write code manually, your throughput is perhaps 20 lines an hour. With 16 parallel agents, you are producing hundreds of lines an hour. My job is to maintain that velocity by unblocking agents, not by writing the lines myself.
Unleashed Linux/Unix Power: AI agents absolutely love the Unix philosophy. They thrive on individual tools invoked via the CLI and simple config files. This environment gives agents raw, unconstrained operating system access, making them incredibly powerful.
Zero-Friction Scalability: Tailscale means I can add compute instantly. If I need 32 cores tomorrow, I plug in another PC and it joins the network. No networking hassle.
Decentralized Control: I can monitor the entire fleet and review outputs from my main dev machine, my laptop in the break room, or even my phone. I’m always connected to the orchestration hub.
👎 Cons
You have to be realistic about this kind of power.
Cognitive Load: Managing 16 threads is intense. It can feel slightly assaulting. It pushes the boundaries of how much parallel information a human can track and process in real-time.
Output Metrics can be Misleading: Using "lines of code" as a success metric is dangerous and psychosis-inducing. Producing hundreds of lines an hour means nothing if the resulting system doesn't build or solve the problem. High throughput demands rigorous human validation.
