How This Solo Builder Ships Features While Sleeping with a 5-Machine Local

Key Takeaways

• Alex Finn's build-and-review loop with Claude Code and local models like OpenClaw automates feature shipping on 5 machines.
• Key takeaway: set up Tailscale and allocate tasks by model strength.

What Changed — The 24/7 Local Software Factory

Alex Finn, creator of Vibe Code Academy, runs a five-computer local AI setup that lets Claude Code ship features while he sleeps. His stack: three Mac Studio 512 GB machines, a DGX Spark, and a custom RTX 5090 build. All coordinated through a fleet dashboard he built himself.

The key insight? Unlimited local inference changes the economics. "Unlimited local inference changes the use-case math in a way a $20 cloud subscription never can," Finn says. Instead of paying per token or per request, you pay once for hardware and run as many agent loops as your machines can handle.

What It Means For You — The Build-and-Review Loop

Finn's core workflow is two Claude Code loops running in parallel:

1. The Build Loop: Claude Code writes code, runs tests, and creates features autonomously. It's assigned to the most capable local model (like GLM 5.2 or Qwen 3.6) on the fastest machine.

2. The Review Loop: A separate Claude Code instance reviews the build loop's output. It checks for bugs, style issues, and security vulnerabilities using a different local model (like Ornith 1.0 or Hermes).

This separation prevents the same agent from rubber-stamping its own work. The review loop can reject code and send it back to the build loop with detailed feedback—all without human intervention.

Finn allocates tasks by machine and model capability. "GLM 5.2 handles complex logic, Qwen 3.6 handles RAG and retrieval, and Ornith 1.0 handles security scanning," he explains. Each machine runs a dedicated agent with failover baked in—if one machine goes down, another picks up its tasks.

Try It Now — Setting Up Your Own Local Loop

Step 1: Install Tailscale

Tailscale is the glue. Even on a single machine, it lets one agent manage your entire hardware fleet. Install it on all machines:

# On each machine
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

Step 2: Choose Your Local Models

Finn recommends:

• OpenClaw (open-source): Best for autonomous agent loops. Runs on Mac Studio with 512 GB unified memory.
• Hermes (Nous Research): Better at instruction following and structured output. Good for review loops.
• GLM 5.2 (z.ai): Handles complex logic and multi-step reasoning.
• Qwen 3.6 (Alibaba): Optimized for RAG and retrieval tasks.
• Ornith 1.0: Specialized for security scanning.

Step 3: Create the CLAUDE.md Configuration

In your project root, create a CLAUDE.md file that defines your build and review agents:

# Build Agent
- Model: OpenClaw (via local endpoint)
- Tasks: Write code, run tests, create features
- Scope: src/ directory, tests/
- Constraints: Must pass existing tests before marking complete

# Review Agent  
- Model: Hermes (via local endpoint)
- Tasks: Review build output, check for bugs, verify style
- Scope: All PRs from build agent
- Constraints: Must flag any security issues, reject if test coverage < 80%

# Failover
- If build agent machine goes down, fall back to review agent machine
- If both down, alert via webhook

Step 4: Run the Loop

Start both agents in separate terminal sessions or as background processes:

# Terminal 1: Build loop
claude code --agent build --model openclaw --task "Implement feature X"

# Terminal 2: Review loop
claude code --agent review --model hermes --task "Review last build output"

Finn uses a fleet dashboard he built to monitor both loops, but you can start with simple log files or even tmux sessions.

Step 5: Add Security Scanning

Use Ornith 1.0 as an always-on security scanner that feeds findings into Claude Code:

# Run security scan on every code change
claude code --agent security --model ornith --task "Scan src/ for vulnerabilities"

This runs in a third loop, continuously analyzing code for issues and creating tickets for the build agent to fix.

Why This Works

The local setup eliminates two bottlenecks:

1. Cost: No per-token charges. Run as many agent loops as you want.
2. Latency: Models respond in milliseconds on local hardware. No API round trips.

Finn's five agents with failover means his software factory never stops. "The build loop and review loop in Claude Code ship features while he sleeps," the source notes.

Hardware Recommendations

If you're starting from scratch:

• Mac Studio 512 GB: Best for running large models like GLM 5.2. Unified memory means you can load a 70B+ parameter model.
• DGX Spark: Nvidia's workstation. Best for models that need CUDA acceleration.
• RTX 5090 build: Best for inference speed on smaller models. Use for the review loop.

Finn runs three Mac Studios for the heavy lifting, one DGX Spark for CUDA-specific tasks, and one RTX 5090 for fast inference on the review loop.

The Bottom Line

You don't need five machines to start. A single Mac Studio or even a powerful PC with a good GPU can run both build and review loops. The key is separating the concerns—different models for different tasks, Tailscale for coordination, and CLAUDE.md for configuration.

As Finn puts it: "Unlimited local inference changes the use-case math." Your code ships 24/7. You just review the results in the morning.

Source: lennysnewsletter.com