All About AI

My Hands-Free AI Streaming Setup (CodeRabbit + Claude Code)

By · · 5 min read

I wanted to stream AI automation work on Twitch, but the setup is annoying — three machines (DGX Spark, Mac Mini, MacBook), one camera, and no spare hands to switch scenes while I'm typing into Claude Code. So I built a voice-and-chat-controlled OBS rig, end to end, using a strict agentic engineering loop: Claude Code writing, CodeRabbit reviewing, both running on the same PR until each phase passes clean. This post is half about the rig, half about the loop — which I think matters more.

Watch the video:

Quick disclosure: CodeRabbit sponsored the video. The workflow opinions below are mine — I'd been wanting to test a "model writes, model reviews" loop on a real project and this gave me an excuse.

What I wanted

The end state was simple to describe and a pain to wire up:

Underlying stack: OBS WebSocket for scene control, FFmpeg for the streaming layer, Parakeet running on the DGX Spark for local STT (low-latency, no API call per word), small Node services on each machine for the listeners.

The agentic loop (this is the interesting part)

Instead of one-shotting it with Claude Code, I broke the work into phases and put a review gate between each phase. The pattern:

  1. Write a PRD up front (full system requirements — devices, scenes, commands, latency targets)
  2. Write a CLAUDE.md defining the per-phase workflow (branch → implement → tests → review)
  3. For each phase:
    • Claude Code (Opus 4.7, dangerously-skip mode) reads the PRD, picks the next phase, creates a branch
    • Implements, runs the test suite, commits
    • Triggers the CodeRabbit CLI agent as a sandboxed reviewer — major/minor findings stream back to Claude Code
    • Claude Code autonomously addresses findings, re-tests, re-reviews until clean
    • Opens a PR — CodeRabbit's GitHub app reviews it again at PR level (different lens than the CLI pass)
    • Claude polls for PR comments, applies fixes, re-pushes
    • Merges when both gates pass clean
  4. Loop into the next phase

This is the same agentic-loop shape I described in the 3-part AI agent system — skill + headless + tools — but with an explicit second AI sitting in the review role. The interesting property is that the two models check each other. Claude Code wrote the code; if it missed an edge case, CodeRabbit usually catches it. If CodeRabbit nitpicks something pointless, Claude Code argues back via the fix attempt and the next review either agrees or pushes harder.

Phase 1 caught one major and one minor finding (package issue + an OBS WebSocket type). Second review pass: clean. PR-level review surfaced four actionables + three nitpicks. Round-tripped those, clean on the second PR review, merged. Total active time on phase 1: ~15 minutes of supervised loop, mostly watching.

What this changes about how I work

The single most useful thing this loop produces is permission to walk away. With a single-model agent, you tend to babysit — you don't fully trust the output until you've eyeballed it. With a two-model loop where the reviewer is independently strong, you can let it run, come back in 20 minutes, and find a merged PR with the rough edges already sanded down.

That changes the unit of work from "one careful interaction with the agent" to "spawn a phase, do something else, check back". This is the same shift I wrote about in the long-running browser-automation post — same pattern, different domain.

Things I think matter for making this loop actually work:

The rig running

By the end of the build, the stream rig actually works. Voice "switch to DGX" → OBS swaps scenes with about a second of lag. Push-to-talk dictation drops transcript into the focused text field — same effect as built-in macOS dictation but powered by the local Parakeet model, so no round-trip to a cloud STT and no cost per token. Twitch chat commands hit the same OBS WebSocket bus through a small listener. !start and !end from chat literally start and stop the Twitch stream via FFmpeg.

Limitations I haven't fixed yet:

What I'll try next

The natural extension is to put a Claude Code agent on the stream itself, like I did in the Twitch agent post — but now with this hands-free rig underneath, so the agent can also drive scenes and respond to chat in real time. That gets to a fully autonomous stream where I show up, hit start, and the rig + agent runs the show.

If you want to drop by while this is live, the Twitch link goes up in the AI_automata Discord when I'm streaming.

Resources

FAQ

What I wanted?

The end state was simple to describe and a pain to wire up:

What this changes about how I work?

The single most useful thing this loop produces is permission to walk away .

What I'll try next?

The natural extension is to put a Claude Code agent on the stream itself , like I did in the Twitch agent post — but now with this hands-free rig underneath, so the agent can also drive scenes and respond to chat in real time.