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. Each stage's deterministic steps run as tested Python scripts, so runs stay consistent.
- 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.
LONG HORIZON
A team that carries the work, not just the next step.
Point it at an issue or a whole epic and it works mostly on its own, the way a capable engineer would: it researches what it doesn't know, plans, builds and reviews its own work, and comes to you when a call needs a person.
Mostly autonomous
Each stage runs end to end in its own session. Multi-phase builds keep going on their own, and every handoff starts the next stage.
Asks, doesn't guess
Open questions are tracked, never quietly absorbed. When a decision is genuinely yours, it arrives as a short brief with the options laid out.
Picks up where it left off
GitHub holds the state, so work can pause and resume, later that day or next week, without losing the thread.
MANY OPERATORS, ONE CODEBASE
Every operator commands their own team.
Several people can run the factory on the same repo at once. Each operator runs a coordinator for every issue or epic they have in flight, and GitHub keeps everyone's progress visible to everyone else.
Your own team
Each operator runs several coordinators at once, one per issue, story or epic, each with its own 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 contact point for each piece of work.
Every issue or epic gets its own coordinator: the chat you talk to while one or more agents carry that work through every stage, each in a fresh session in its own worktree. Open several side by side to deliver several issues, stories or epics at once.
/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 in its chat. Its agents' plan summaries and build reports are relayed up to the coordinator.
- 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.
And on what Claude Code ships: it builds on the platform's own tools rather than reinventing them.
- 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.
- 06
Capability over cost.
Built on Anthropic's published guidance, it spends what the work takes to get it right. Token efficiency is not the goal.
- 07
Judgment for Claude, bookkeeping for code.
Every skill hands its deterministic work to plain Python scripts (gathering state from GitHub and git, writing results back, opening and closing worktrees), so the same inputs give the same moves on every run, and an offline suite of around 2,500 tests keeps them that way. Claude's tokens go to the decisions, not the busywork.
- 08
Built on Claude Code, not around it.
It uses what Claude Code already ships: the bundled
/code-reviewand/security-reviewskills, fresh sessions, worktrees and question cards. It uses GitHub's own issues, sub-issues and PRs too. It adds the process on top, so it gets better as they do.
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. The reviews themselves run on Claude Code's bundled /code-review and /security-review skills.
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
Claude Code's /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 platform built for a modern AI world.
Not a demo. Every stage, gate and guardrail exists because real delivery needed it.
- ~2,500offline tests
- ~300commits of iteration
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, across internet search, online mapping and finance.
Among the best
Worked alongside some of the best engineering teams in the industry, Microsoft among them.
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.
BUILT FOR CAPABILITY, NOT ECONOMY
It spends tokens to buy quality.
ctrl-freaq is tuned for the strongest models, not the cheapest run. Every stage starts with a fresh context, reviewers work blind, findings get a second opinion, and each operator runs a whole team of agents. That's where the results come from, and it isn't frugal. None of it is spent on busywork: the routine steps run as tested Python scripts, so the budget goes into reasoning.
It also takes so much of the process off your hands that you stop being the limit. Budget becomes the throttle on what an operator ships.
- Models. Tested on Claude Opus 4.8 and later, with the best results on Opus 5.5.
- Individuals. Plan for a Claude Max 20x subscription, not Pro.
- Teams on the API. Budget several hundred US dollars a day per operator, or more.
INSTALL
Two lines in Claude Code.
Ask Claude to check the plugin first, then install it and run setup. Setup detects your lint, test and build commands and writes the gates the pipeline reads.
01 Check it first recommended
claude "Hey Claude, before I install the https://github.com/reactive-org/ctrl-freaq Claude Code plugin please make sure it's safe."02 Install in Claude Code
/plugin marketplace add reactive-org/ctrl-freaq/plugin install github-pipeline@reactive-tools/github-pipeline:setup