The Forkable Factory

I was standing in a LEGO factory when I first saw a 3D printer work.

I was still a student. The factory was what you'd expect. Enormous injection moulding machines. Tool steel cut to tolerances I couldn't picture in my head. Millions of identical parts flying down conveyors. The whole place was built on one unshakeable idea – if you wanted a physical object, you made a mould, and the mould made the object. That was the law.

Somewhere in that same building, I saw a small machine slowly extruding plastic in thin layers, building a shape that had existed only as a file a minute ago.

I don't know if anyone else in the room felt it. For me, something cracked. I had been conditioned – by school, by the factory, by the whole industrial logic I walked through every day – to believe that physical objects came from tools. Steel, pressure, committees, specialists, months of lead time. And suddenly, here was a machine on a desk that could make an object without any of that. No mould. No setup. You pressed a button and a thing appeared.

That moment quietly shaped the next ten years of my life.

I chased it. I left moulding and started a small 3D printing company. I became obsessed with cutting out whatever part of the process was still slow. 3D modelling was slow, so I started using scanners – point a sensor at a physical object, digitise it in minutes, print it back out in a slightly new form. Another gate gone. Another layer of "only specialists can do this" falling away.

A few years later I ended up building something that would have been unthinkable when I started. A small team, a pile of AI tools, and a workflow that could turn a child into the hero of their own custom-written, custom-illustrated, printed and shipped storybook. Every child a hero of their own story. Five years earlier, that required a publisher, an illustrator, a print run, a distributor. Five years later, five people and a laptop could do it for one specific kid in one specific family.

Every time, the same pattern. A capability that used to require a large organisation collapsed into something a small group, or even one person, could do. The tools changed. The impulse stayed. You saw the thing that didn't exist yet, and you built it.

I've been living inside this pattern my whole adult life.

Now I'm living inside a new version of it.

For months I've been spending my mornings inside a folder on my laptop that behaves less like a project and more like a collaborator. It reads context files at the start of every session. It runs commands I designed. It remembers things I wrote months ago. When I tell it to go screen the sources, it knows which sources, what filters, where the output goes. It's not an assistant. It's closer to a personal operating system – an agentic environment where the unit of work is the folder, not the task.

I use it for knowledge work. And I keep catching myself thinking: I've seen this shape before.

Here's the part I find harder to talk about.

I think about people I've worked with over the years. Engineers with twenty, thirty, forty years of experience. The ones who carry the tribal knowledge of a product nobody ever wrote down. Why that supplier was chosen in 2009. Why that tolerance is tighter than the spec actually requires. Which parts of the compliance matrix are load-bearing and which are cruft from a regulation that changed eight years ago.

Some of them don't have a decade of working years left. And looking around, there isn't exactly a line of fresh engineers waiting to receive what they know. Getting qualified new people into industrial product development is hard. Keeping them is harder. A generation of quiet, hard-won knowledge is walking toward the door, and most organisations haven't built the thing that catches it.

I feel something about this I don't quite have a word for. Not nostalgia. Closer to fear, mixed with a stubborn sense that there's a way through.

Because if the pattern I've been living really is real – if capabilities keep collapsing from large organisations into small teams – then the same collapse is coming for product development itself. And if it's coming anyway, I'd rather help shape what it looks like.

Here is the thesis, as cleanly as I can say it.

Physical products should be developed the way software is. Context-engineered. Agent-assisted. Version-controlled. Fork-first. Built in public.

The spec, the BOM, the supplier network, the compliance matrix, the stage-gate, the test protocols, the tribal knowledge – all of it should live as structured files inside a repo an agent can read, reason over, and act inside of. The binder on the shelf becomes a git history. The retiring engineer's knowledge becomes context that outlives him. The handover becomes a clone.

And then – this is the part that still feels slightly insane when I say it out loud – the whole thing becomes forkable. You take someone else's industrial product, clone the repo, modify it for your market, let the agents reason over the new constraints, generate the updated compliance dossier, ship the parts through a distributed manufacturing API, and have a physical thing in your hands in weeks instead of years.

I call it the forkable factory. Not because it's a finished idea. Because it's the name I'm putting on a pattern I can't stop seeing.

The uncomfortable part of product development today is how much of the job is fighting the fragmentation itself. Twenty different tools. Spec in Word. BOM in Excel. Compliance in PDF. Suppliers in email threads. CAD in one system, tests in another, decisions in a meeting nobody took notes in. The cognitive load of holding it all together in your head is enormous. The waste is real – time, money, materials, and the quiet tax of every small error compounding down the line.

I'm not saying the forkable factory arrives tomorrow. I'm saying three ingredients are already on the table. Agentic development environments, where a folder becomes a reasoning substrate an agent can live inside. Distributed manufacturing APIs, where Xometry and Protolabs and Hubs have quietly turned the physical supply chain into something closer to a curl request. And compliance as code – standards as structured files, test protocols as executable scripts – early, ugly, real. None of them finished. All of them converging. Nobody has stirred them together yet.

Ten years from now, I think every serious physical product on earth will have a public, forkable, agent-native development repo. I think three-person teams will ship regulated hardware from bedrooms. I think the knowledge that used to walk out the door with a retiring engineer will live in files that survive him. I think "sovereign product development" – one small team, one country, no permission, a real industrial thing – will stop being a fantasy and start being a Tuesday.

I might be wrong about the timeline. I don't think I'm wrong about the direction. I've watched this pattern repeat three times already.

So here's what I'm doing about it.

I'm building a reference implementation. Not a product, not a startup, not a pitch deck. A real repo with a real fake industrial product inside – spec, BOM, suppliers, compliance, stage-gate, test protocols, agents that reason across all of it. I want to see what breaks first. I want to see which parts of the dream are ready and which parts are still science fiction. I want to publish the whole thing in public and let people tear it apart.

I'm going to write build logs. Messy ones. The kind where I admit what didn't work this week and what I changed my mind about. The maker movement was built on build logs, not whitepapers. I'd like to honour that.

And I'm looking for fellow weirdos. The people who've stood on a factory floor and also know what a context file is. The engineers who've managed a BOM and also shipped an agent. The hardware hackers who've looked at an agentic OS and quietly thought: wait, couldn't you point this at a product instead of a codebase?

If that describes you, I'd like to know you exist.

I don't have a clean ending for this. I don't think the idea is clean yet.

What I have is a memory of standing in a LEGO factory as a student, watching a machine make something without a mould, and feeling the ground shift under me. I didn't understand it then. I just knew the rules I'd been taught had a crack in them.

I've felt that three times now. Each time I chased it. Each time the tools got smaller, the teams got smaller, and the things we could build got bigger.

I'm feeling it again. I don't fully understand this one yet either. But I know what the crack looks like by now.

The material is changing. It always does. The impulse doesn't.

Build the thing. Show the work. Let it fork.