A CLAUDE CODE + GITHUB SOFTWARE FACTORY
You set direction.
Claude runs the factory.
Work as analyst, architect and lead, solo or alongside your team. Every operator commands their own team of agents: Claude drafts, plans, builds and reviews many issues at once, each in its own worktree, all through GitHub.
THE PIPELINE
Six stages. One session each.
Every stage ends with a handoff that starts the next, so context stays clean. Research and slicing are detours, taken only when the work needs them.
- drafterTurns loose feedback into one well-formed issue. Open questions get tracked, never absorbed.
- researcherA dated, cited dossier — only when the work turns on external truth it shouldn't guess at.
- slicerCuts big work into increments you could demo, filed as sub-issues GitHub rolls up.
- plannerDesigns the approach against repo precedent and your docs, pinned to a commit.
- resolverImplements in its own worktree, opens the PR, loops with review until approved.
- evaluatorJudges the PR against its origin issue, gates on branch health, merges per your policy.
THE OPERATOR
You move up the stack.
Analyst
Shape the intent. Answer the open questions. Approve the requirements.
Architect
Review the plan before a line is written, while changing course is still cheap.
Lead
Read the evidence, not every line. Spend your attention where the risk is.
Claude does everything in between — concurrently, one worktree per issue, for every operator.
MANY OPERATORS, ONE CODEBASE
Every operator commands their own team.
Several people can run the factory on the same repo at once. Each operator drives their work through a coordinator, and GitHub keeps everyone's progress visible to everyone else.
Your own team
Each operator runs their own coordinator and their own team of agents, side by side with everyone else's on the same repo.
GitHub is the shared memory
Issues, plans, PRs and reviews all live on GitHub, so every operator and every agent works from the same state.
No trampling
If someone else's PR already claims an issue, the factory stops and asks: review it, comment, or wait. Stale work is only taken over on your say-so.
Isolated by design
Every issue gets its own branch and worktree, a branch can't be checked out twice, and concurrent runs never share staging.
THE COORDINATOR
One chat runs your whole team.
Point it at an issue or a whole epic and it drives the work through every stage, each in a fresh agent session in its own worktree. You stay in one conversation and make the calls.
/github-pipeline:coordinator <issue>
- Decisions come to you. Every choice and every task that needs you arrives as a card, never buried in the output.
- Follow along from one place. Plan summaries and build reports are relayed up to the coordinator's chat.
- The routine runs itself. Worktrees open, sync and close as a matter of course; it only stops to ask when something is unsafe.
- Multi-phase builds keep moving. Phases continue on their own, and a phase that needs your eyes asks in-session.
- Trust, but verify. Every stage's claims are checked against GitHub before the next one starts.
- Tidy by default. When a piece of work closes, its finished stage sessions are archived.
PRINCIPLES
Built on how Anthropic ships.
- 01
Code is no longer the bottleneck.
The steps around the build still run at human speed. The factory is built for those.
- 02
Every stage leaves an artifact.
Issues, plan comments, PRs and reviews. GitHub is the audit trail.
- 03
Review is continuous.
Verified before the PR, reviewed and security-reviewed on every PR, and re-gated against the latest base before merge.
- 04
Nothing lands except through a PR.
A write-protected main. Worktrees open and close cleanly — never a silent discard.
- 05
A person owns every outcome.
Claude proposes, verifies and fixes. You decide what to build and what ships.
THE REVIEW STACK
Every layer catches what the others miss.
Modelled on how the Claude Code team does code review: verification, AI review, a security pass and human approval scaled by risk, each a gate of its own.
Merges what was reviewed
An approval covers one exact commit. If the branch moves after review, or the base moves after gating, the merge waits until it's gated again.
A second opinion
When a serious reviewer finding is dismissed, an independent, context-blind check confirms it before it leaves the loop.
Security on every PR
A security review runs on every PR's path to merge, and an open finding blocks approval until it's fixed or dismissed with a reason.
Risk sets the bar
Declare the paths that always need a person. Review effort scales with the change, and every PR states its risk and how to revert it.
Your repo steers the reviewer
Tell the reviewer what failure looks like in your code. Findings that keep coming back are proposed as new guidance.
Review quality, measured
Every finding is recorded by outcome (fixed, wrong, intentional or didn't matter), with rounds-to-pass reported per repo.
BATTLE-HARDENED
Forged shipping a complex enterprise tele-health platform.
Not a demo. Every stage, gate and guardrail exists because real delivery needed it.
THE MAKER
Decades of shipping, distilled.
The factory encodes how software actually gets delivered, learned the long way.
Web pioneer
Building for the web since its earliest days, including online maps before Google Maps.
Microsoft
Engineering inside one of the world's largest software organisations.
Founder
Co-founded a B2B SaaS company and saw it through to a sale.
Enterprise systems
Complex platforms where failure is expensive and review is not optional.
Built by Dan Washusen at reactive.org enterprises.
INSTALL
Two lines in Claude Code.
Then run setup — it detects your lint, test and build commands and writes the gates the pipeline reads.
/plugin marketplace add reactive-org/ctrl-freaq/plugin install github-pipeline@reactive-tools/github-pipeline:setup