Dark Factory — AI Agent Orchestration System

5 markdown files. A few CLI commands. A script to talk to a kanban board. That's it. That's what rebuilt a 6-year-old ERP/CRM in a month — a project estimated at 1 year with 2 developers.

I tried GitHub Copilot. Fancy auto-complete. Kinda sucked. But the real problem was what it did to my brain. I was so focused on the minute details of what the AI wrote — checking every line, validating every suggestion — that I stopped thinking about the big picture. How does piece X connect to piece Y in file Z? What API endpoints does this feature need? What should the interface feel like? I felt dumber. I was thinking smaller. So I uninstalled all AI coding assistants and went back to writing everything myself.

Google released Anti-Gravity — an agent inside an IDE built off VS Code. Not auto-complete. An actual agent that could see your full project across files, generate entire files, edit existing ones. I was curious enough to try it.

I opened a completely empty folder and typed: "Program a blackjack game. Choose any language. $5 minimum bet up to $1,000 per hand, up to 3 hands at once, proper rules for double downs and splits, start with $1,000, and a button to add another $1,000 to the bankroll."

The agent started creating files, editing files, asking for permissions. Then a browser window popped up and the agent started clicking around testing its own software. Five minutes later, there was a working blackjack game I could open and play. I was blown away — and honestly, terrified. This was it. This was AI coming to replace people like me.

A few hours later I had baccarat, poker, a slot machine — an entire casino suite. Gemini was even generating images for game art assets. There were bugs everywhere, sure. I'd hit deal before the animation finished and we'd be playing with one card each. Craps dice weren't actually changing but somehow I was winning. But I could look at the code, see the issue, and tell the AI: "line 116 is firing twice" or "chain these animations with callbacks synchronously so one finishes before the next starts." I knew what good software looked like. The AI just needed me to tell it.

Over a couple of months I started giving Anti-Gravity small jobs on real work projects. I'd guide it through data schemas, interface designs, how things should work — a lot more detailed than "build me a blackjack game." The results were good.

But the real change was in my head. Instead of thinking about which files I needed to touch or which repositories to work in, I was thinking about user experience, about what functionality needed to exist, about the system as a whole. This was different from the brain dulling I'd felt with Copilot. I wasn't thinking smaller. I was thinking bigger.

Then one morning in February 2026, I woke up and thought: "What if I just fully embrace AI as my coding agents? I stop coding. I architect systems. I hate coding anyway — but I love creating and architecting systems."

I downloaded Codex CLI and Claude Code CLI and went all in.

At work, I'd been building an ERP/CRM application for 6 years. I work for a startup in the steel industry — an R&D arm of a larger company. We run experiments and try new things. Over the years, other entities within the company wanted their own version because we had a fast, easy way to manage customer records and create quotes/orders.

So we ended up with 3 entities on the same repository, with if/else decision trees scattered everywhere for the slight differences between each one. Each entity had its own unique repo, plus 3 shared repos with different environment variables. The code was getting impossible to maintain across all 3. I knew they needed to converge into a single multi-tenant app, but I estimated that at 1 year of work with 2 developers. We didn't have that kind of time.

I put all 3 repositories in a folder and told the AI: "Combine these into 1 app with multi-tenant management." I got about what a lazy dev would give you. It made a monorepo with a bunch of extensions, and all the garbage was still in the code — just in 1 repo instead of 3.

That's when it clicked. The AI was following patterns from 5 different developers across 6 years of shifting priorities and one-off changes. You can't hand an AI 6 years of accumulated tech debt and say "fix it." You have to treat it as a brand new project. We already knew what every piece should do, how it should work, what the data schema should be. We just needed to document it all out and let the AI build it fresh.

I told my boss: "Let me spend $200 on AI tools this month. If it works out, you get a brand new application for all 3 entities — faster, sleeker, and I'll knock out 90% of the feature request list in the process." He said: "You're saying $200 gets me everything we want in a month? Yeah, of course."

One month instead of one year. One developer instead of two. I didn't know if it would actually work.

After the first week I had full authentication, full CRM, full multi-tenant SaaS management. Encrypted tenant modules where I could enable specific features per entity. Users could be active across multiple tenants. The architecture was finally right.

Week 3: live on the first tenant. Week 4: second tenant. Two days later: third tenant. All completely rewritten. All working. All superior to the previous version. 50–60 hour weeks, burning through every token allotment I had, but it was done.

After the rebuild, I started looking at the generated code more carefully. Duplicate code in a lot of places. Different ways of doing the same thing. My first thought was: I don't really care about duplicates — the AI maintains this, not me, and it can read it just fine. But I also knew that a cleaner codebase would make the AI even better at maintaining it. The problem was that the codebase was already bigger than any single AI's context could handle.

Modern AI CLIs have parallel agent systems. That's when it clicked. I don't need one agent trying to do everything. I need specialized agents with focused jobs:

• Scout — scans the codebase with brief context to find problems, feature requirements, or refactor opportunities
• Strategizer— takes the Scout's findings and plans how to fix or build the request
• Standardizer — defines the standards that should be followed for the specific code change
• Implementor — makes the actual code changes
• Verifier — confirms the changes match the standards and fulfill the original request

Then there's Dark Factory — the orchestrator. I talk to Dark Factory. Dark Factory spins up the right agents for the job. The name comes from dark factories in manufacturing — fully automated facilities that run with the lights off because no humans are on the floor.

I pointed Dark Factory at the full codebase and said: "Refactor everything. Deduplicate code, standardize title bars, back buttons, theme color adherence." A few hours later I had a fully documented epic with 12 individual stories — standards outlined, changes implemented, everything verified. I could test immediately, and the difference was obvious: faster, cleaner, consistent.

The agents were documenting their work in markdown files, which was useful for me, but I needed visibility for the whole team. So I built a data schema that feeds a kanban board. Dark Factory has a script that CRUDs to an API as it works — splitting tasks into epics, stories, and comments in real time.

Now there's a dashboard where anyone can see what's being worked on, where agents are in the process, what standards are being followed, when files were touched, when functionality changed. And the entire documented journey can be fed through an LLM that summarizes it into plain-English patch notes for anyone who just wants to know what changed this week.

Dark Factory started with 1 repository. It now operates across 5. Implementors and Verifiers run in parallel. Every repository has a standards.md file that the agents reference for that specific codebase.

• 5 markdown files — one per agent, defining its purpose and behavior
• A CLI command — the Dark Factory orchestrator that coordinates the agents
• A script — CRUDs to a kanban board API so the agents document their own work
• A dashboard — kanban UI to see it all laid out, plus LLM-generated patch notes for the layman
• standards.md per repo — the rules each agent follows for that codebase

That's it. No one ever believes me. Web developers and engineers are totally skeptical — until they see what it's building. Then they can't help but want to be involved.

• LLM CLI coding agents — primary runtime, parallel sub-agent execution
• Markdown — agent definitions, repository standards, documentation
• Custom kanban API — epics, stories, comments, real-time agent progress tracking
• LLM summarization — patch note generation from agent documentation

I wrote V3 of the karaoke production platform by hand. I wrote V2 of my personal AI health system by hand. The next versions of both will be written by Dark Factory. And they're going to be amazing as a result.

If you have a legacy codebase that needs a rebuild, a dev workflow that needs AI agent orchestration, or you just want to see what happens when you stop thinking about code and start thinking about systems — I've done it. AI-driven development workflows, agent architecture, automated documentation and progress tracking. The future of software development isn't writing code. It's directing the things that write code.

Get in touch and let's talk about what you need.