Personal · Open source · macOS
Robowright
Hand Claude Code a whole stack of changes and come back to finished, reviewed work.

Robowright is an open-source system for getting big jobs done with Claude Code. You first agree on a plan with one session. Each change is then built in its own git worktree, checked by a reviewer that never saw it written, and handed back for you to accept. You launch the sessions yourself, and they work while you do something else. I designed its strategy, approach and skills, and it wrote most of its own code. It’s beta, and macOS only.
Who it’s for
It’s for engineers already running several agent sessions at once. It’s also for anyone running one at a time and watching every step, who wants to grow past “agent babysitting” without giving up quality. And it fits a large, tangled project that needs breaking down and working in the background, when you can’t give it your full attention. It only works with Claude Code, and it’s built for one engineer rather than a team.
Why I built it
Running the agent loop became frustratingly repetitive. At work I was refactoring a large area of untested legacy code, and the models of the time couldn’t untangle it. One-shotting it wasn’t close, and even at a couple hundred lines per commit I was still catching bugs.
So I built up a workflow, solving one process failure at a time, until I started to see the patterns behind it and wanted to codify them. I built Robowright on my own time and computer, partly because I needed it for Feal too. Open-sourcing it let me use it at work, and lets anyone else try it.
How I built it
Each piece answered something that broke. Poor agent decisions in the refactor taught me the agent works better when characterizing a file into a behavior table first, then writing behavior-driven tests from it. A meaningful chunk of those tests couldn’t actually fail, so now each new test has to prove it can. An adversarial review closes each chunk, and each agent writes its results to disk so it keeps to one task.
Those became Lego pieces of trust around the agents. They grew to whole stacks of pull requests from a full day in the background while I worked on something else. It became powerful, but also expensive, so the work is split by model. By default Fable plans, Opus builds the judgment-heavy changes and reviews, Sonnet takes the grunt work, and Haiku reads token-heavy inputs like logs. With a thorough plan and an Opus reviewer, Sonnet can take general coding too.
On Robowright itself, I stayed high level: I set the strategy and approach, designed the skills, and tested and refined it. Most recently, it ported Feal’s launch-blocking beta fixes to Android. I skimmed the code, ran a thorough QA pass before launch, and had basically no feedback for it.
Security or usability?
On my own laptop, I was fine running it with more risk than I’d accept at work. Once it was going public, and onto my work machine, security had to matter more. Hardening it has felt like a never-ending thread I keep pulling, one workaround after another. Every security improvement tends to make the system more rigid or clunkier to use. It’s a balance between security and usability, and the hardening is still imperfect.
Where it falls short
It’s experimental, and sometimes the system stumbles over itself. The state machine that runs it can be overly rigid, and the dashboard still has many kinks. Even on a Claude /loop, the lead session that’s watching the others sometimes misses a check-in or a message, and the work stalls for 15 or 30 minutes. Few people use it, so there are rough patches I don’t even know about. It’s all open source though, and I encourage anyone to take it and tweak it to their own workflow.