Pandacorp
AI-operated software factory · since June 2026
A software factory I built and run on my own. I give it a product idea, and AI agents do the work under my direction. This portfolio is one of the products that came out of it.
- The problem
- Working alone, documentation and tests are the first things to slip.
- What I did
- I built a reusable factory: one rulebook, full documentation, checks nothing can skip.
- The result
- A complete software factory, run by AI from idea to tested product.
Building a whole product alone, with no team behind it
Building products alone usually forces a trade-off: ship fast and let documentation, tests and consistency slip, or slow down to a crawl to keep them. I wanted every project I build, including this portfolio, to go from idea to a documented, tested, production-grade product without a team, and without re-deciding the same engineering questions from scratch each time.
I built the factory that every product I make runs through
Instead of prompting AI project by project, I built a reusable factory: standards, pre-approved criteria and gates that fail closed, which any product I build runs through. The AI agents execute a real lifecycle, from product research and specification to design, architecture, build, review and release, instead of autocompleting code.
Rules decided once, and lessons kept from every build.
Every project starts from the same rulebook: 121 engineering criteria I decided once, covering how things get named, what has to be tested, which security defaults apply, and when a change has to stop and wait for me. On top of that, each build writes down what it learned, a library that disappointed, a trap that cost an hour, a pattern that worked. The next project starts with those lessons already loaded, so the factory gets stronger the more I use it.
From a rough idea to a fully documented product.
I hand the factory a product idea that is still vague, and it does the product work before a line of code exists. It researches the problem on the web, compares apps that already solve something similar, and writes the documents a real team would write: the product specification, one requirements document per feature with verifiable acceptance criteria, the technical blueprint, the work orders that split it into units, and the visual design. Nothing gets built from a paragraph in a chat.
Nothing is done until every check passes.
When the agent that wrote the code says it is finished, a separate step decides whether that is true. It runs the formatter and the linter, the typechecker and the unit tests, hunts for dead code and circular imports, and then opens every page in a real browser. Only that step can mark work as done, and a check that never ran counts as a failure. That rule came from a build that was green on tests while one page rendered empty.
Three projects, run by one person
The factory has carried three ideas from a blank repo through specification and design, and two of them all the way to a finished, tested build. The site you are reading is one of them. Of everything the factory evaluates, only ideas that survive an explicit viability check get built at all.
I can take a vague idea to a documented, tested product on my own, because I built the process that makes it repeatable instead of doing it by memory each time.