Build Your OwnDark Factory
A dark factory is a fully automated manufacturing facility that runs without human workers — lights off, machines on. This kit brings that concept to software development: a complete Claude Code project scaffold where the AI agent does the implementation work, hooks enforce the guardrails, and you play the architect. One solo founder, one AI, production-grade code.
What is a Dark Factory?
The engineering pattern behind shipping production software with a small team and an AI agent.
Memory-first
CLAUDE.md is the agent's working memory — stack decisions, conventions, guardrails, and definition of done. The agent reads it before every session; you update it when conventions change.
Hook-enforced quality
Hooks fire automatically: secret guard before edits, formatter after edits, i18n parity on every message change, typecheck before the agent can stop. Quality is structural, not habitual.
Session-sized prompts
Each of the 10 implementation prompts is scoped to one focused Claude Code session and ends with acceptance criteria and verification steps — a session that has no DoD never ends cleanly.
Everything Claude Code needs to build your app
The kit is layered: project memory at the top, executable config and commands below, then prompts that drive each session, docs that answer every architectural question, and scripts + CI that enforce quality automatically.
How a single session works
Every prompt in the kit defines the same four-phase session pattern. Claude Code follows it automatically once the kit is in place — the human job is to pick the next epic and review the output.
The dark factory loop
Each session reinforces the next. CLAUDE.md evolves as conventions change; the build plan tracks which epics are complete; hooks enforce quality at every step. The loop is self-reinforcing by design.
Dark Factory best practices
The principles baked into the kit — learned by building with AI agents, not theorizing about them.
Scope each prompt to one session
Every prompt in the kit ends with acceptance criteria and verification steps. A session that has no definition of done is a session that never ends — or ends with untested code.
CLAUDE.md is the contract — keep it current
When you change a convention, update CLAUDE.md immediately. Claude Code reads it at session start; a stale file means the agent works against outdated assumptions.
Let hooks enforce what you would forget
The hook system fires automatically: guard.sh blocks edits to .env and destructive migrations, post-edit.sh runs the formatter, and the Stop hook runs typecheck before you can exit. These are not optional reminders — they are gates.
End every session with /ship-check
The /ship-check command is the explicit definition-of-done ritual: typecheck, lint, all tests, i18n parity, and a manual verification checklist. It is not optional.
Migrations are append-only
Expand, migrate, contract. Nullable first, NOT NULL later. The /new-migration command enforces this workflow. The previous deployment must keep working against the newer schema — that is the instant-rollback guarantee.
Test payment code first
Money paths have the most dangerous failure modes. Write the test before the implementation — always. The kit makes this explicit in its conventions and testing strategy.
Subagent orchestration
The kit is scaffolded for a single Claude Code session driving the main context. As the codebase grows, spawning specialized subagents becomes the lever: they protect the main context window, parallelize independent work, and bring stronger review capacity on-demand.
The pattern is: main agent holds architectural context, delegates bounded tasks to subagents, reads their results, and synthesizes. Subagents start cold — they have no memory of prior sessions — so the quality of your briefing determines the quality of their work.
Subagent orchestration best practices
The rules that keep multi-agent workflows coherent instead of chaotic.
Call advisor before substantive work
The advisor (a stronger model) sees your full conversation history. Call it before writing code, before committing to an interpretation, before building on an assumption. Orientation is not substantive work — writing is.
Spawn Explore agents for codebase-wide searches
Codebase searches that would take 3+ queries and flood the main context window belong in an Explore agent. It reads excerpts and returns a focused report — keeping your context clean for implementation.
Parallelize only genuinely independent work
Send independent tool calls in a single message. Never fire a tool that depends on a prior result in the same batch. Sequential-dependent calls must be sequential — parallelizing them introduces race conditions on shared state.
Brief agents like a colleague who just walked in
A fresh agent has no conversation history. Include: what you are trying to accomplish, what you have already ruled out, relevant file paths, and what form the answer should take. Terse command-style prompts produce shallow work.
Call advisor again when you are done
After writing, make the deliverable durable first (save the file, commit the change), then call advisor. If the session ends during the advisor call, a durable result persists. On tasks longer than a few steps, call advisor at least once before writing and once before declaring done.
Common questions
What the kit is, what you can build with it, and how to get it.
What is the Dark Factory Kit?
A complete Claude Code project scaffold: CLAUDE.md project memory, a hook system (.claude/settings.json) with secret guard, post-edit formatting, i18n parity checks, and a typecheck gate on stop; five slash commands (/implement, /review, /ship-check, /new-migration, /i18n-sync); ten sequenced implementation prompts from bootstrap to store apps; eight architecture docs (strategy, data model, architecture, i18n, build plan, testing strategy, launch checklist); guard scripts; and a ready-to-run GitHub Actions CI pipeline.
What kind of product can I build with this kit?
A production-grade multi-platform two-sided marketplace: web (Next.js 15 App Router), iOS, and Android (via a Capacitor shell from the same codebase). The kit includes auth (email OTP, Google, phone), a task/offer/chat lifecycle, background jobs, machine translation, payments, full-spectrum testing, and a launch checklist covering compliance, SEO, and ops.
How do I get the kit?
Connect with Vladyslav Donchenko on LinkedIn and send a DM requesting the Dark Factory Kit. The link to his profile is on this page.
What infrastructure does it require?
Vercel (preview deployments per PR, instant rollback) + Supabase (Postgres, Auth, Storage, Realtime) + Inngest (background jobs) + Upstash Redis (rate limiting). At early scale the total cloud cost stays well under $100/month.
Request the Dark Factory Kit on LinkedIn
The kit is shared on request. Connect with Vladyslav on LinkedIn and send a DM — he responds to every message personally.
Building production AI/ML systems for real estate companies across Europe. The Dark Factory Kit distills the Claude Code patterns VSBD uses internally to ship SaaS platforms with small, focused teams.
Explore our services
Building this into your platform?
If you are using Claude Code to build a SaaS platform and want to talk architecture, hooks, or subagent patterns — reach out. We also build these platforms end-to-end.