Dev tooling
Autonomous spec-driven development
Write the spec — the Factory builds the product in daily windows and opens PRs. You review from your phone.
AI coding assistants still need you at the keyboard
Your side project doesn't move unless you sit down, restore context, and drive. The bottleneck is no longer the coding — it's your chair time.
The Factory turns a spec into a backlog it works through on a schedule
Every day, unattended. Each task is handled by a fresh Claude Code session that implements test-first, verifies, and opens a pull request. You interact asynchronously: merge PRs, answer its questions, file issues. It runs on any machine — a laptop, a VPS, macOS, Linux, or Windows.
Triage
Reads everything humans left overnight — issues, PR comments, answered questions, inbox notes, board moves — and plans the day. If the plan is missing or stale, a dev window runs triage itself first — no separate manual step.
Dev window
- Pick a task
- TDD
- Verify
- Open a PR
A fresh session per task, repeating until the window closes, the list runs dry, or you say stop.
Report
An honest summary — done, blocked, needed — posted to a daily-log issue (and Telegram, if enabled).
↻ repeats daily — Report feeds the next Triage
Human — async, never blocking
File issues
Answer questions
Merge PRs
Why it doesn't fall apart
State lives in files
Not conversations. The backlog, project docs, and mid-task handoff notes are files in the repo. Every session starts cold and reads them — no long-conversation degradation, no lost context, fully inspectable at any moment.
Humans are async, never blocking
When the Factory needs a decision, it files a needs-human GitHub issue and keeps working on other tasks. Answer whenever; the next triage folds it in.
The driver is dumb on purpose
A zero-dependency script spawns sessions and enforces hard limits — window length, session timeouts, session caps, an emergency STOP file. Intelligence lives in prompts and skills; enforcement lives in machinery.
Your checkout is yours
Every session runs in a throwaway isolated worktree. The Factory never switches your branch or touches your uncommitted work.
Self-heals, and flags what it can't
A wedged internal worktree resets and rebuilds itself from origin instead of failing forever. A machine-level supervisor watches for factories whose scheduled windows keep aborting before a session even starts — stuck, not idle — and flags it once, instead of quietly going dark.
Rules enforced by machinery
A guard hook mechanically denies sessions the dangerous moves: merging their own PRs, committing to the base branch, editing their own instructions. Not "please don't" — can't.
Smart spending
Every task carries a model and effort hint — a cheap model for well-specified CRUD, a stronger one for novel logic — corrected over time against actual usage evidence. Budget = hard caps on window hours, sessions, and turns.
Open source (MIT)
Driver, prompts, and schedulers are all public at github.com/MJTeixeira/claude-plugins (factory/ tree) — nothing is a black box.
Nothing merges without proof
Auto-merge only fires once checks are green — and if a repo has no CI at all, its own test suite has to pass first. Anything touching a path you've flagged as high-risk (auth, payments, migrations, and the like) parks for your review instead of merging automatically. Before any of it lands, an independent AI session re-grades the change against that task's own acceptance criteria from a fresh checkout — no recorded pass, no merge.
You choose the leash
Autonomy levels control how far the Factory goes before a human has to look.
| Level | Behavior |
|---|---|
| PR-only (default) | Every task becomes a PR; a human merges. |
| Auto-merge | The driver merges factory PRs once checks are green and an independent grading pass confirms the task's acceptance criteria — see "Nothing merges without proof" above. |
| Milestone gates | Auto-merge within a milestone; stops at boundaries for sign-off. |
Two ways to work with an agent
You drive
Assistant — synchronous back-and-forth
Human at the keyboard, driving every step in real time.
It drives
Factory — scheduled, async
Machine works on schedule; you review from your phone whenever.
Feeding it & watching it
Input, any time
GitHub issues and PR comments (canonical), a zero-setup markdown inbox, optional Notion/Jira mirrors, and an optional two-way GitHub Projects board — drag cards, the Factory notices.
Any forge, any tracker
Works with GitHub or Bitbucket Cloud as the forge, and GitHub Issues, Jira, or Discord as the tracker — including a two-way Jira board sync for teams whose planning already lives there.
Phone dashboard
A live console over every factory on the machine — status, task table with PR links, session summaries, log tail, and spend (today + all-time). Each card also shows the next triage/dev fire time and the window's declared duration, so a glance tells you when it runs next and for how long. Runs privately over Tailscale; add it to your home screen and run/pause/stop factories from bed.
Telegram notifications
Window start/end, per-task results with cost and PR link, failures — even when the failure is bad enough that the factory itself can't speak, a dumb outer safety net still reaches your phone.
Doctor
A one-command health check covering every failure mode that has actually cost a night's run — auth, schedules, permissions, config drift. A machine-level watchdog runs it daily across all factories.
Setup is a conversation
Getting started
Once per machine: git clone https://github.com/MJTeixeira/claude-plugins ~/.factory/runtime. Then open Claude Code in your project and say "set up a factory here". It interviews you, turns your pasted notes into spec files, runs the setup wizard, compiles the backlog, and offers a supervised first run. From then on it runs daily on its own.
Proof, not promise
This very website is a Factory project — it triages its issues and ships its changes through the same loop described here. The studio runs a fleet of ten factories across two machines nightly, including full game projects. A typical completed task costs $1–4 with Sonnet — an operating-cost data point, not a product price.
Built on the same skills
The Factory is autonomous — it drives. The Skillset is interactive — you drive.
Every factory session runs the same published plugin skills described here — TDD, review before PR, persistent docs — one distribution channel, version-pinned to the deployed runtime and health-checked, so sessions can never silently run stale skills.