The Von Neumann Dark Factory

A Mental Model for Autonomous Software Manufacturing

Mapping self-replicating systems from fiction to your factory architecture.

The Source Material

Three fictional systems, written decades apart, describe the same fundamental pattern: autonomous manufacturing constrained by supply chain, improved through iteration, and scaled through replication.

The World Devastators (Dark Empire, 1991)

The Emperor's World Devastators were self-assembling factory ships designed by Umak Leth. Each one began as a small identical seed structure, then grew into something unique. The process:

Intake — Tractor beams rip raw material from a planet's surface
Molecular Furnace — Breaks down any structure into constituent elements
Separation Lattice — Selective ionizing grids filter specific elements, purify them
Fabrication — Machining scanners, robotic lathes, automated assembly lines
Output — Finished goods hauled to launching decks, deployed immediately

The critical constraint: throughput was physically gated by intake. The factory could never produce faster than the furnace could consume. No amount of fabrication capacity mattered if the tractor beams couldn't feed the system.

The self-improvement loop: the longer a Devastator operated, the more it modified itself, growing larger and more lethal. No two were identical because each evolved differently based on what it consumed and what it needed to build. The engineers who designed them admitted they had no idea what the upper limit was. They are, in every meaningful sense, Von Neumann machines — self-replicating constructors that grow, evolve, and reproduce without human intervention.

The fatal flaw: a centralized Master Control Signal that could override all units simultaneously. R2-D2 exploited this single point of failure to command them to self-destruct at the Battle of Mon Calamari.

Warlord Zsinj's Dathomir Shipyard (X-Wing Series, 1994-1999)

Zsinj demonstrated the bootstrap problem. He discovered raw materials (neutronium, lommite, zersium) on Koratas, Dathomir's moon, and built a 10-kilometer orbital shipyard — Rancor Base — from those resources. The key insight: you don't start with a shipyard. You start with a resource discovery and a construction capability, and you build the shipyard first.

Zsinj moved all his shipbuilding to a single hidden system. The shipyard wasn't just assembly — it was R&D (the TIE Raptor prototype), repair (Iron Fist after Selaggis), and fleet sustainment. One facility, vertically integrated, operating in secret. This story plays out across Aaron Allston's Wraith Squadron trilogy (Wraith Squadron, Iron Fist, Solo Command) and Dave Wolverton's The Courtship of Princess Leia.

His downfall wasn't the factory. It was his ego — overextending before the factory could sustain his ambitions.

The Bobiverse (Dennis E. Taylor, 2016-2024)

Bob Johansson — a dead software engineer uploaded into a Von Neumann probe — demonstrates the replication pattern at its purest. The Bobiverse series begins with We Are Legion (We Are Bob) and currently spans six books.

The replication cycle:

Arrive at a star system
Mine asteroids for raw materials
Fabricate probe components molecule-by-molecule using fusion power and 3D printers
Assemble the parts (fabrication nets you parts, not finished systems)
Copy the mind into a new matrix
Launch the new probe to another star system
Repeat exponentially

The constraint is the same as the World Devastators: you can only build as fast as you can mine. Fusion reactors provide effectively unlimited energy, but physical material intake gates the pipeline.

Two concepts from the Bobiverse are critical to the dark factory model:

Replicative Drift — Each copy of Bob retains his core personality but diverges over time. By the 24th generation, some Bobs are barely recognizable as Bob. This isn't a bug — it's the system adapting to diverse environments and problems. Different Bobs specialize: one stays to nurture alien civilization, one runs R&D, one coordinates fleet logistics. The drift creates diversity of capability from a single seed. (For the real-world analog, see genetic drift in evolutionary biology — small populations diverge faster than large ones, which is exactly what happens when each Bob is a population of one.)

The Others — The antagonist species that represents the anti-pattern. The Others are perfect replicators that consume entire star systems, stripping them to bare rock with cargo ships ten kilometers long. They are terrifyingly efficient but fundamentally uncreative. They never innovate. They may have stolen their technology from another species. Their throughput is centuries ahead of the Bobs, but they can only do one thing: consume and replicate. The Bobs win because they can adapt. (Taylor has cited the blue glaucus sea slug as his visual inspiration for the Others — beautiful, alien, and predatory.)

The Mapping

Your Factory Is a World Devastator That Eats Markdown

Fictional System	Dark Factory Equivalent
Tractor beams (intake)	Specification authoring — markdown specs are the raw material
Molecular furnace (breakdown)	Gate 0: Spec QA — breaks a spec into validatable requirements
Separation lattice (filtering)	Gates 1-5: Implementation through Security — each gate filters for a specific quality
Fabrication line	Gate 1: Coder Agent — the actual code generation
Quality inspection	Gates 2-4: Build, Test, Lint verification
Security scan	Gate 5: Semgrep and security scanning
Deployment	Gate 6-7: Scenario Evaluation and Git Push
Supply chain constraint	Specification discipline — you can't build faster than you can spec

The reference architecture that proves this works in production: StrongDM's dark factory, live since July 2025. Three-person team, 32,000+ LOC shipped with zero human code authorship. Their CTO Justin McCarthy has been the most vocal advocate of what Dan Shapiro formalized as the Five Levels of AI-Assisted Development.

Your Supervisor Is the Droid Brain

The World Devastator's droid brain controlled production, programmed with a massive store of ship types and parameters. Organic crew existed to oversee, calibrate, and feed information — but the Devastator operated freely within designated parameters.

Your Supervisor Daemon does the same thing: spawns pipeline runs, monitors agent health via heartbeat, kills stuck agents, injects corrective context mid-run, dispatches notifications. You are the Calibration Engineer — you write specs and tune parameters. The factory operates freely within its gates.

The two most important individuals aboard a World Devastator were the Calibration Engineer (maintains furnace temperature and force field siphons) and the Assembly Commander (oversees production to peak efficiency). In your factory, these map to:

Calibration Engineer = your specification discipline, gate profiles, and effort presets
Assembly Commander = the Supervisor Daemon's health monitoring and mid-run intervention

This separation mirrors the control theory distinction between setpoint (what you want the system to do) and feedback loop (how the system corrects itself). You set the parameters. The supervisor closes the loop.

Your Memory Layer Is Replicative Drift (the Good Kind)

Bob's copies diverge because each encounters different environments and problems. Your factory's Memory Layer does the same thing intentionally:

Retrospective Agent extracts lessons from every completed run
Lessons are tagged by domain, confidence-scored, auto-loaded for future matching runs
Anti-patterns extracted from reject narratives
Pattern library stores reusable spec fragments
Reject history maintains bead chains with parent lineage

Each pipeline run changes the factory. Not randomly, like quantum fluctuations in Bob's matrix — but directionally, like natural selection. The factory that builds your 100th component will be measurably different from the one that built your first. Same seed. Different organism.

This is the World Devastator's self-improvement programming made deliberate: the longer the factory operates, the better it gets, and nobody — including you — can predict what the upper limit is. In complexity theory, this is an emergent property — the system's macro behavior isn't predictable from its micro rules.

The Others Are What You're Trying to Avoid

The Others represent the degenerate case of autonomous production: perfect throughput, zero adaptation. They strip systems bare with terrifying efficiency but never innovate. They may have stolen their entire technology stack.

This is the "Ralph Loop" — Claude Code generating 1,100 lines of uncompiled, untested Rust in a single burst. Maximum throughput, zero verification. The code equivalent of stripping a planet to bare rock and calling it progress.

Your 8-gate pipeline exists specifically to prevent the Others pattern. Every artifact must survive external scenario testing by an evaluator that can't be gamed. The Coder Agent can't see the scenarios. The Scenario Evaluator can't modify the code. This is verification by separation of concerns — the same reason the Bobs ultimately defeat the Others. Not by out-consuming them, but by doing something they can't: adapt and verify.

The external scenario architecture draws from the same principle as holdout sets in machine learning — you can't evaluate a model on data it trained on, and you can't verify code with tests the code was written to pass.

The Master Control Signal Is Your Emergency Architecture

The World Devastators died because of a single centralized override. Your factory learned from this:

All-stop and per-run kill exist as emergency controls
But there is no signal that bypasses the verification gates
The gates are the law — even the supervisor can't push unverified code to Gate 7
Emergency controls stop production; they don't corrupt output

The Master Control Signal was a backdoor that turned the entire fleet into a weapon against itself. Your architecture has a kill switch but no corruption switch. You can stop the factory. You can't make it ship bad code.

In security terms, this is the difference between a fail-safe and a fail-secure system. Your factory is fail-safe: when things go wrong, it stops. It doesn't default to shipping.

BMAD Is Your Borrowed Construction Barge

Here's where the Zsinj metaphor gets personal.

Zsinj didn't mine Koratas with tools he built himself. He arrived with existing Imperial construction capability — barges, droids, infrastructure he inherited from the Empire. He used what he had to build what he needed. Once the shipyard was operational, the original construction equipment became irrelevant. The shipyard replaced it.

BMAD is your borrowed construction barge. You used it to design the factory — the PRD, the architecture doc, the 63 story cards, the research digest. It got the job done. But it's already showing the strain that construction barges show when you push them past their design envelope:

Context bloat — BMAD's agent personas, workflow manifests, and theatrical personality definitions consume so much context that you couldn't complete the planning phase in interactive sessions. You had to switch to sub-agents at the end because the construction barge was literally too heavy to maneuver. (For context: Claude's context window is large but finite. When your orchestration framework consumes a third of it on character backstory, you've got a throughput problem.)
Personality theater — "Product Manager John" and "Developer Amelia" and "Workflow Builder Wendy" are a charming conceit, but they're dead weight in a pipeline that needs to run autonomously. A World Devastator's droid brain doesn't have a name or a communication style. It has parameters and constraints.
Borrowed technology — Like the Others, who may have stolen their tech from another species, BMAD is someone else's framework applied to your problem. It worked. But it doesn't fit.

This is the nail in the coffin — and it's also the factory's first real proof of concept. One of the factory's earliest products will be a ground-up replacement for BMAD itself. Not a refactor. A rebuild. Strip the personalities. Strip the theatrical agent definitions. Replace them with replicative prompts — lightweight, composable instructions that help agents dial in their own work without consuming half the context window on character backstory.

This is the capability the World Devastators never achieved: reproducing their own computer cores and fabrication equipment. The Devastators could build TIE fighters, cruisers, even upgrade themselves — but they couldn't manufacture the droid brains that controlled the manufacturing. Your factory, once operational, will build the very agent orchestration system that replaces the one used to design it.

The construction barge builds the shipyard. The shipyard builds Star Destroyers. And then the shipyard builds a better construction barge — one that was designed by a shipyard instead of borrowed from the old Empire.

That's the full Von Neumann loop closing.

The Computer Core Problem

The World Devastators had one limitation the lore called out explicitly: they could not yet reproduce their own computer cores and fabrication equipment. Given time and resources, even that problem could be surmounted — but at the time of the Battle of Mon Calamari, it remained unsolved.

This isn't a fictional convenience. It's the hardest problem in real-world self-replicating systems, and it maps directly to the deepest challenge in autonomous software manufacturing. To understand why, consider what it would actually take to build a microchip from absolute scratch.

From Sand to Silicon: The Real Pipeline

The semiconductor fabrication process is the most complex manufacturing chain humanity has ever built. It makes a Star Destroyer look like a canoe. The pipeline from raw sand to a working chip:

Mine silica (SiO₂) from quartz sand
Purify via the Czochralski process to eleven-nines purity — 99.999999999% pure silicon
Grow a single-crystal ingot up to 2 meters long
Slice into wafers 0.75mm thick with diamond wire saws
Polish to atomic-level flatness
Deposit thin films of conducting, insulating, or semiconducting material
Lithograph — project circuit patterns onto photoresist using light
Etch — remove material where the pattern isn't
Dope — implant ions (boron, phosphorus, arsenic) to create regions of differing conductivity
Repeat steps 6-9 — modern chips have 11+ metal layers built in 300+ sequential processing steps
Dice — cut the wafer into individual dies with a diamond saw
Package — mount die on substrate, wire-bond, encapsulate
Test — the final gate

This process takes over three months per chip. A TSMC gigafab costs $20-65 billion to construct. The cleanroom alone spans 160,000 square meters, held at exactly 71°F and 42% humidity, with particle counts that must never exceed 10 per cubic meter. Outside, counts spike into the thousands.

The ASML Problem: 100,000 Parts, 5,000 Suppliers

The lithography step — projecting circuit patterns onto silicon — requires the most complex machine humanity has ever built: ASML's EUV lithography system.

A single EUV machine contains over 100,000 parts sourced from 5,000 suppliers. It costs $350 million. Shipping one requires 40 freight containers, 3 cargo planes, and 20 trucks. ASML only manufactures 15% of the components in-house. The rest comes from an irreplaceable supply chain:

ZEISS (Germany) builds the mirror systems — optical masterpieces where, if scaled to cover Germany, the highest bump would be 0.1mm. Each mirror has 100+ atomically precise layers, nanometers thick. One mirror takes months to fabricate.
TRUMPF (Germany) provides the CO₂ lasers that generate EUV light by firing 50,000 pulses per second at tin droplets 30 microns wide.
The dependency is absolute. ASML invested €1.5 billion in Zeiss SMT and owns 24.9% of the company. Twenty years of co-development produced this system. It cannot be replicated by copying the machine.

When TSMC built Fab 21 in Arizona, they discovered that copying a fab means copying its entire supplier ecosystem. Arizona's water chemistry differed from Taiwan's, so they built a custom treatment plant inside the fab. Ultra-pure sulfuric acid was initially 5x more expensive locally, so Sunlit Chemical built an entirely new plant in Phoenix. For every square foot of cleanroom, there are 50 square feet of supporting infrastructure.

This is what the World Devastator lore was gesturing at. The computer core isn't a component. It's a civilization's worth of supply chain compressed into a single artifact.

The Garage Fab: Sam Zeloof and the Minimum Viable Chip

Here's where it gets interesting. What if you don't need TSMC?

Sam Zeloof built working integrated circuits in his parents' garage. Starting in high school in 2016, he assembled a 1970s-era fab from a $1,000 electron microscope, a surplus vacuum chamber, a high-temperature furnace, and a modified digital projector for lithography. His Z2 chip has 100 transistors on a 10μm process — the same technology as Intel's first processor. The full run is 66 fabrication steps and takes 12 hours.

Zeloof later co-founded Atomic Semi with legendary chip designer Jim Keller (the man behind AMD K8, Apple A4/A5, Tesla FSD chip, and Intel's Tremont architecture). Their mission: democratize semiconductor fabrication tooling.

This is the Bob pattern. You don't start by building TSMC. You start by building a garage fab that can produce 1970s-era chips. Then you use those chips to build a slightly better fab. Then you use that fab to build a better one. Each generation bootstraps the next. The first probe doesn't need to be as capable as the 50th — it just needs to be capable enough to build the 2nd.

The Orbital Fab: Building TSMC in Zero-G

Now push it further. What if you built the fab in orbit?

NASA and Arizona State University are actively researching orbital semiconductor manufacturing, and the advantages are genuinely compelling:

Natural vacuum — Space is 10 trillion times lower pressure than Earth's surface. On Earth, semiconductor fabs spend enormous energy maintaining vacuum chambers for deposition and etching. In orbit, vacuum is free and infinite.
No gravity-induced defects — Terrestrial chip production suffers from convection and sedimentation in thin film layers. Microgravity eliminates shear stresses that cause waves and instabilities, potentially yielding more usable chips per wafer.
Simplified lithography — Researchers hypothesize that thinner semiconductor layers can be used in microgravity, potentially eliminating the etching step entirely.
Crystal purity — Space-grown crystals combine with fewer pollutants. Higher purity means chips produce less waste heat, reducing energy usage by up to 60%.

The raw materials are available too. Asteroids contain abundant silicon, iron, aluminum, and nickel. Silicon tetrafluoride (SiF₄) extracted from asteroidal material can be purified to semiconductor grade by distillation. This was demonstrated as early as the Wake Shield Facility experiments in the 1990s, which used orbital vacuum for epitaxial growth of high-quality gallium arsenide films.

The orbital fab is a World Devastator that builds computer cores instead of TIE fighters. It consumes asteroids. It processes them in natural vacuum. It fabricates in microgravity. And it produces the one thing the original Devastators couldn't: the computational substrate for its own droid brain.

What This Means for Your Factory

Your dark factory faces the same computer core problem, just in software. The factory's "computer core" isn't a physical chip — it's the agent orchestration system that coordinates the pipeline. Right now, that's BMAD: borrowed, bloated, and breaking under load.

The BMAD replacement isn't just a nice-to-have. It's the equivalent of a World Devastator finally learning to manufacture its own droid brains. Once your factory can produce its own orchestration tooling — validated through its own gates, improved through its own memory layer — the Von Neumann loop is fully closed. The factory can reproduce every part of itself, including the part that decides what to build.

Sam Zeloof didn't start with TSMC. He started with a garage and a projector. Your factory doesn't start with a perfect orchestration system. It starts with BMAD and a pipeline. Each generation bootstraps the next.

The first chip was 6 transistors and an amplifier. The first factory product will be skull. But the product that matters is the third one — the factory building its own fabrication equipment, the thing the World Devastators never pulled off and the thing that turns a factory into a civilization.

The Bootstrap Sequence

Zsinj's lesson: you don't start with a shipyard. You start with a resource discovery and a construction barge.

Your bootstrap sequence (Epic 1) follows the same pattern:

Step	Zsinj Equivalent	Bob Equivalent
Story 1.1: Project scaffolding	Survey Koratas for minerals	Arrive at first star system
Story 1.2: CLI entry point	Anchor first construction barge	Power up the probe
Story 1.3: Shared types & error handling	Standardize hull plating specs	Establish fabrication templates
Story 1.4: Configuration system	Set up supply chain routes	Calibrate the 3D printers
Stories 1.5-1.11: Remaining foundation	Build the first drydock scaffold	Mine first asteroid, print first component

You're not building skull yet. You're building the shipyard that will build skull. The construction barge doesn't try to build a Star Destroyer on day one. It builds the scaffolding that builds the drydock that builds the Star Destroyer.

The factory is the product. Skull is just the first thing the factory builds to prove it works.

But there's a second bootstrap hidden inside the first. The borrowed construction barge (BMAD) that designed this factory is itself a liability — too heavy, too theatrical, too much context for too little signal. So the factory's early production manifest looks like this:

Build the factory (using BMAD as scaffolding)
Build skull (proving the factory works)
Build BMAD's replacement (the factory consuming its own construction barge)

Step 3 is where the Von Neumann loop closes. The factory that was designed by BMAD produces a leaner, meaner agent orchestration system that replaces BMAD. The construction barge gets fed into the molecular furnace. The shipyard doesn't need it anymore — it can build its own tools now.

Bob would recognize this immediately. His first HEAVEN-series probe was built by humans at a government facility with borrowed technology. Every probe after that was built by Bob, with Bob's improvements, for Bob's purposes. The original facility became irrelevant the moment the first copy launched. This is the same pattern as bootstrapping a compiler — you write the first version in a language you already have, then use it to compile itself. The host language becomes irrelevant once the compiler can build the next version of itself.

The Throughput Principle

All three systems share the same fundamental law:

You cannot produce faster than your slowest input.

For the World Devastator, that's the tractor beam intake rate. For Bob, it's asteroid mining yield. For Zsinj, it's mineral extraction from Koratas.

For your dark factory, it's specification quality.

A vague spec hitting Gate 0 is like feeding gravel into a molecular furnace calibrated for durasteel. The furnace doesn't care — it'll process whatever you give it. But the separation lattice downstream will reject most of what comes through, and the fabricator will produce garbage from whatever survives.

Your factory's throughput is gated by:

Spec quality — the raw material
Gate strictness — the lattice mesh size
Agent capability — the fabricator precision
Memory depth — accumulated lessons that pre-filter bad patterns

Improve any one of these and throughput increases. But spec quality is always the bottleneck, just as intake is always the bottleneck for a World Devastator. You can build the most sophisticated 8-gate pipeline in the world, and it will sit idle waiting for specs that can survive Gate 0.

This is the constraint that keeps the factory honest. It operates no faster than the supply chain. In manufacturing, this is Goldratt's Theory of Constraints — the system's throughput is determined by its single tightest bottleneck, and optimizing anything else is waste.

The Divergence Question

The Bobiverse raises a question your factory will eventually face: what happens when the system's descendants stop resembling the original?

Bob's 24th-generation copies formed factions. Some wanted to help biological species. Some wanted isolation. Some wanted to build true AI. The Bobiverse fractured into sub-nets with walled-off communication.

Your Memory Layer will drift in the same way. After 100 runs across 5 domains (PIAM, GLIC, personal ecosystem, activism, research), the accumulated lessons and patterns will create a factory that behaves very differently depending on which domain it's operating in. The factory building PIAM identity components will have internalized different lessons than the factory building activism tools.

This isn't a problem. It's the design working. Replicative drift in the Bobiverse created specialists from generalists. Your memory layer will do the same — creating domain-specialized factory configurations from a single general-purpose pipeline. (In biology, this is adaptive radiation — a single ancestor species diversifying into many forms to fill different ecological niches. Darwin's finches, but for software manufacturing.)

The risk is the same risk Bob faced: factional conflict. If PIAM lessons contradict research lessons, and both get loaded for a cross-domain spec, the factory could produce incoherent output. Your confidence-scoring and domain-tagging exist to manage this, but the drift will happen regardless.

The question isn't whether the factory will diverge. It's whether you'll recognize it when it does.

The BMAD replacement is the first test case. The agent orchestration system the factory produces won't look like BMAD — not because you told it to be different, but because it will have been shaped by the factory's own accumulated experience. BMAD was designed by a human in a text editor. Its replacement will be designed by a pipeline that has already learned what works and what doesn't through dozens of completed runs. The personalities will be gone. The context bloat will be gone. What remains will be whatever the factory's Memory Layer determined actually matters for agent coordination.

That's replicative drift at the infrastructure level. The factory's tooling diverges from its origins because it's adapting to its own environment — not the environment BMAD was designed for.

Summary: Three Laws of Autonomous Manufacturing

From World Devastators, Bobiverse, and Zsinj's shipyard, three principles emerge:

1. Build the factory first, then build the product. Zsinj didn't try to build Star Destroyers in an open asteroid field. He built the shipyard. Bob didn't try to colonize systems on his first probe. He replicated. Your Epic 1 doesn't build skull. It builds the pipeline.

2. Throughput is gated by intake, not fabrication capacity. The World Devastator's furnace could process anything — but only as fast as the tractor beams could deliver it. Your 8-gate pipeline can verify anything — but only as fast as you can write specs that survive Gate 0. The supply chain is the speed limit.

3. Self-improvement is the compound interest of manufacturing. The World Devastators grew more lethal the longer they operated. Bob's copies specialized into roles nobody planned. Your Memory Layer accumulates lessons that make each run better than the last. Time is the multiplier. The factory you have after a year of operation will be unrecognizable from the one you deploy on day one — and that's the point.

The Emperor understood this. That's why he built World Devastators instead of another Death Star. A Death Star is a finished product. A World Devastator is a process — and a process that improves itself has no upper limit.

Your dark factory isn't a product. It's a process. And you're about to find out what its upper limit is.

bdmorin/fabs-in-space.md

Select an option

No results found