Inspiration
Code got cheap. Understanding didn't.
In a randomised trial of 52 developers, AI assistance measurably impaired conceptual understanding, code reading and debugging — with no significant efficiency gain (Shen & Tamkin, arXiv:2601.20245). I kept hitting the same thing myself: agents produce more than I can meaningfully review, and "the tests pass" quietly becomes the whole quality bar.
I kept coming back to how I delegate to people. Delegation starts with trust. I trust a team to own an outcome, answer for it, and tell me when something's wrong — and how much scrutiny I apply depends on how much depends on the thing. I don't review a throwaway script the way I review an auth change.
So I built the receiving team, not another autonomous coder.
What it does
Software Factory is a portable set of agent skills you install into a repository you
already have. It runs on the agent harness you already use. There's nothing to host, no
account, and no runtime of mine in your stack — removing it is git revert.
Eight skills carry one loop: onboard learns your project and process, plan establishes intent and stakes, deliver builds in an isolated workspace, verify runs checks and independent review, understand explains the change and checks that you followed it, observe watches the work, plus visualize and context.
The distinguishing move: when a human owns the outcome, work does not reach teammate review until that person can explain the change. The factory stops on purpose, where stopping matters. Work that arrives from a signal, webhook or schedule, inside a path you already authorised to run unattended, runs straight through — repair, verify, ship, report. Depth follows consequence, the way it does with a real team.
How I built it
I built it with itself, overnight, across parallel agent sessions in Conductor — a manager coordinating integration, builders in isolated worktrees, reviewers that were separate sessions with separate context, and an observation loop ticking every five minutes that watched sessions and pull requests and nudged idle work.
What I learned
Independent review caught almost everything. A packaging bug where npm exec through a
symlink could skip installation entirely and exit successfully. A guide whose step 7 edited
one file while step 8 read another that no step created. An installer that shipped a skill
but never installed it. Not one came from the author re-reading its own work.
The research was corrected thirteen times before I'd publish it — mostly for asserting what competitors lacked rather than what had actually been checked. Every correction is still visible in the repo.
An agent refused an unsafe instruction. A "safe" credential check I'd approved would have printed a Slack token into a transcript. The agent wouldn't run it and explained why. That's the behaviour I want at 3am.
Challenges I faced
My own alignment gate didn't hold. During a live test, the factory went from one question straight to a finished build — inventing four assumptions and writing a spec I never agreed to. Its own account: it read a later named checkpoint as permission to run unaligned until then. Both skills said "agreed spec" as though agreement were self-evident, and nothing made it happen. I fixed it, then audited every other skill for the same defect class and found two more — including on the signature gate, which described retries but never said the change stops.
Then I overcorrected. The fix made the gate unconditional, which would have blocked an agent-triggered repair at 3am and made the factory useless for exactly the work it should absorb. The gate is now conditional, and the condition is agreed up front — because an agent deciding in the moment that nobody is needed is the failure the gate exists to prevent.
Ownership collisions. Two sessions edited one file minutes apart. Two fought over one preview URL. Both resolved the same way: declare ownership, never infer it.
Durability. The loop ran fifteen hours on a schedule that lived in one chat session's memory, written to no file. It was never durable in any sense, and I documented exactly that rather than pretending otherwise.
What's honest about this
The research establishes that comprehension degrades under AI assistance. It does not establish that this gate fixes it — no study I cite tested one. I built the evaluation suite that could eventually answer it, and I say so in the repo rather than claiming a result I don't have.
Try it
git clone https://github.com/forward-runtime/software-factory.git
node software-factory/scripts/install.mjs /absolute/path/to/your-repo