One project, start to finish
Hand Claude Code a whole stack of changes. Come back to finished, reviewed work.
You're the loop today: review, re-prompt, summarise, start the next session. Robowright writes the loop down and runs it without you.
What's built in
Robowright is the workflows I kept reaching for, written down once as skills and agents, and built around putting the expensive model only where a request carries real judgment. The habits are best practice in AI-assisted engineering, wired in rather than recommended; what's built in is the plumbing between them, so the rest runs without me. Each tile names the file that carries it.
-
The words are settled before the plan, and the plan before the build.
The domain model is settled first, then the plan is grilled in rounds, each question carrying a recommended answer. Units are cut as tracer bullets, and skills and work orders are written for their reader.
The Planner's handbook → -
Small context, by construction.
A long run is made of short sessions, one role each, the window capped, since a session's cost is mostly re-reading its own context. Hand-offs are files, so by default each unit restarts fresh from disk.
The design notes → -
Big things go through a Reader.
A build log, a ledger, an accessibility tree: a small Haiku reader returns the one line the caller needs, and the Worker's context never carries the rest.
The Reader → -
Modes for spend, speed and certainty.
Three profiles trade token spend and speed against certainty. The default puts bounded units on Sonnet and judgment on Opus; a brief can move any unit, and an Opus reviewer gates every one whichever model built it.
The run profiles → -
The grader is never the author.
A Reviewer that never saw the work built judges the artifact and the evidence, never the builder's account. Each unit is held or advanced on a citation, and the whole stack gets an adversarial review before you see it.
The gate review → -
Tests are proven able to fail.
A behaviour change is specified before it is built by someone who reads the contract, not the code, and existing untested logic is characterised before it moves. Every new test is killed by a mutation or declared a guard.
Load-bearing tests → -
It stops for seven named reasons and logs the rest.
A fixed list of decisions is yours alone; a brief can add to it, never take from it. Outside the seven stop reasons, a run takes the defensible default and logs it as assumed.
The stop codes → -
Every document is checked before you read it.
A fresh reader cites or downgrades every load-bearing claim in a change description, a handoff and your owner brief; a document with an open question is not published. The comments a change adds get a pass of their own.
The doc gate → -
The record is written to be read later.
A change description in the form the project asks for, a decision log that keeps the rejected options, an owner brief assembled from the files, a project report at the end.
The Explainer →
What you still decide
Robowright stops and asks when a decision is yours: anything that ships to users, a schema or a public interface, a new dependency, spending past the budget, anything another person reads. Everything below that line it decides itself and writes down. You read the brief, and you accept or replan.
What it isn't
It's beta: the workflows I kept reaching for, written down as skills and agents. It runs on macOS, inside Claude Code, for one engineer. It isn't a hosted service, a team tool or a CI system.
Why I built it
Every long task I gave Claude Code ended the same way: I was the loop. Review the work, pick a cheaper model for the easy parts, ask for a summary, start the next session. Useful work was happening, and my part of it was mechanical.
So I wrote the loop down as the next layer up. Plan thoroughly with one session. Let the rest run without me, each change checked by a reviewer that never saw it being built. Be interrupted only for the decisions that are actually mine. Get a brief at the end that I can disagree with.
When speed or a single thing matters most, a frontier model in a dedicated session still wins. Robowright is for everything beyond that: the second project, the backgrounded one, the stack of changes that runs overnight. It hands you finished work to review and critique, and keeps your judgment for the calls that are yours.
Try it
Clone it into a folder no Claude Code session is granted, run the installer, and read "The crew" in the README. Then hand it something small.
git clone https://github.com/AJschoons/robowright.git ~/src/robowright && bash ~/src/robowright/install.sh