This is my personal software factory.
It turns ideas into working products while I sleep. No babysitting coding agents with prompts all day.
Cursor and Claude Code made writing code way easier. The harder problem is building a system that can context engineer and manage itself.
My factory starts with a Skill called `/factory`. It's the foreman that remembers where the project stands and sends in the right worker for the job.
Factory runs this assembly line:
1. `/factory-plan` - the interviewer
Reads the existing codebase (if there is one), extracts missing context from me via interview, and writes a product brief.
2. `/factory-plan` - the planner
The same skill turns the approved brief into small, testable features and development tasks.
3. `/factory-tests` - the professor
Before anyone writes code, every task gets an exam. This skill defines the success criteria for each task, and how the coding agent can prove to itself that what it built works or needs iteration.
4. `/factory-explain` - the presenter
Explains the plan to me like I'm 10, with visual metaphor and mermaid charts. Now that coding agents can write more code, faster than any human ever could, the new bottleneck is human understanding of the code. This skill solves that.
5. `/factory-handoff` - from CTO to SWE
This packages the brief, plan, tests, safety rails, and stop conditions into one work order. Factory uses the best models for the planning in the previous steps above, then hands the work order to a lower token usage model like Grok 4.5 for execution.
6. Cursor or Claude Code `/loop` - the coffee
The night shift picks one task, builds it, takes its exam, records what happened, iterates if needed, then moves onto the next task. If it gets stuck, circuit breakers stop it from confidently digging a deeper hole while I sleep.
7. `/factory-review` - the teacher grades the homework
The student doesn't grade it's own homework. A fresh agent that never met the builder tries to break the result. The reviewer rereads the original plan, reruns tests, and finds anything that's broken.
8. `/auto-loom-proof` - shows the evidence
Uses browser use and screen records itself performing the tests and adds an 11labs voiceover explaining what's being proven. It sends me the narrated demo video.
9. `/factory-explain` - the code
The factory updates a plain-language owner's manual explaining what actually got built. I understand my own codebase, so I can make decisions without becoming the bottleneck or outsourcing my thinking to AI.
NOTE ON BUILDING AI
Cursor and Claude Code have made writing code dramatically easier. But getting AI to work reliably and at scale for you can't be fully automated.
LLM-as-judge helps, but a judge needs a rubric, examples, and input from someone with subject matter expertise. You still need a human reviewing the work and teaching the system how to perform better.
You can check out my factory on github in the post below.
