Building a factory doesn't mean automating everything.

🙈 I had an idea: a software factory. No hundreds of engineers. A floor that produces the way a pizzeria does: at night, with nobody standing in front of the oven.

Watching AI platforms move, I got it: we were looking at a PARADIGM SHIFT. Not of tools. Of how software gets built.

I stood up a dedicated server. I named five agents. And I went to sleep.

The work was not creating the agents. That's the easy part. What hurts is the rest:

• The RULES. What goes in the oven and what doesn't.
• The HANDOFFS. Who the pizza passes to. With what. Before what.
• The spaces. Everyone their own board. Their repo. Their memory.
• Ticket statuses. PRD READY. QA NEED REVIEW. REVIEW FAIL. No statuses, no line. You have a chat.
• How they talk. Who writes to whom. What gets documented. What gets escalated.
• And above all, everyone's RESPONSIBILITY. Olivia doesn't code. Fígaro doesn't deploy. Luna doesn't patch. Betty takes the order. Tech catches it at the back.

The next morning there were tickets moved. A PR. A QA comment.

It wasn't magic. It was that: a process. A production line. Lights still on. (Dalia still hasn't made it to the deploy shift.)

It's a pizzeria. Not a miracle.

In real plants there's a weird trick: they can turn the lights off. The robots don't need them. That's why they call them dark factories.

I get it easier. It's a pizzeria.

A MACHINE that cooks pizzas. You're not in front of the oven the whole shift. The machine bakes. At night. Nobody has to turn the light on.

But the machine does not invent the pizza.

What goes in is the PRD. Product Requirements Document, if you like the long name. In plain speak: the written order. What to build, for whom, why, and how we know it's done. The raw pizza. Dough, sauce, toppings. If it comes in half-built —no size, no word on whether it's Hawaiian or if it has pineapple, half the recipe still in someone's head— the oven won't save it. It cooks the disaster faster. You get a pizza nobody ordered. And now you have to throw it out. More expensive. Hotter.

Apunto's dark factory is that oven. OpenClaw 2.0. Tickets instead of trays.

And at the window, someone has to CATCH IT. Not a hero. The team. Developer and QA. Did it come out whole? Did something break along the way? Did the process move, or did it jam halfway through the oven and nobody noticed?

And what happens when the pizza gets STUCK inside the machine?

It never reaches the window. The order is still "in the oven." The customer waits. And you don't know if it burned, if the belt jammed, or if that screw that always loosens loosened again.

How do they get it out? How do they clean it? How do they fix it? How much time do you lose?

It's an EXPENSIVE bet. Every minute the machine is jammed, the line isn't cooking. A hung agent. A status nobody moved. A handoff that broke in the middle. A dirty workspace. That's not "a bot bug." That's a carbonized pizza and a wasted shift.

That's why they want the machine always oiled and ready. That's why MAINTENANCE is not extra. It IS the work. The rules. The statuses. How they talk. The responsibilities. If you don't maintain the oven, one day you open it and find three pizzas stuck and a customer who already left.

Without a pizza prepped up front, without people catching it at the back, and without an oiled oven, you don't have a pizzeria. You have an expensive oven making smoke.

If you don't let go of the keyboard, it isn't a factory

A year ago I wrote that automating everything is not the solution. A client asked me to reconcile collections. Two weeks. And he kept doing it by hand to "check" the automatic.

We had added a step. We hadn't removed one.

Because this is also CULTURE. Having technology does not patch a team. It doesn't fix the design. It doesn't fix the processes. It doesn't fix the handoffs. It doesn't fix the communication.

If the team doesn't talk, if the baton doesn't change hands, if nobody knows whose pizza it is… the oven just makes the mess faster. A new APP on top of a broken process is not a factory. It's the same chaos, with a GPU.

The dark factory has the same poison, it just smells like burnt cheese. If Fígaro pulls the pizza and we —four in tech— rebuild it at 11 p.m. "just in case," we didn't build a factory. We duplicated the shift. And the pizza went cold twice.

Already happened to me. (💩 shit happens.)

An automation is not a tool you add. It's a piece of work someone has to STOP doing. Here that someone is us. The operational code. The QA of "let me look at it for a second." The 2 a.m. deploy because "I sleep better that way."

If we don't let go, the agents are theater with a GPU. An oven on, and four people still kneading next to it.

Wanting a dark factory COSTS. It cost me trying it several times.

Breaking the system. Shipping bugs nobody asked for. Making Customer Success, Product, and other teams pull their hair out. Not because the oven was bad. Because I didn't make the objective clear. What we were building this for. What problem would stop existing the day it turned on. And what problems it WAS GOING TO CREATE the day it started to run.

That last one was the punch.

Suddenly we had more releases than ever. The oven was spitting them out. And there weren't enough hands to review things as fast as they came in. QA saturated. PRs nobody could turn over. The customer got pizzas half-cooked.

That's when I got the obvious, late: if you put in something of bad quality, that's what comes out. The oven doesn't fix the dough. It cooks it faster.

Without that, the rest of the company only sees smoke. An expensive machine. Pizzas nobody ordered. And good people wondering why this landed on them.

Some pizzas are made by hand

We can't expect the machine to make EVERY kind of pizza.

There are conveyor-belt pizzas. The ones that come out the same. The ones the oven already knows. A bug with a repro. A fix with tests. A PRD that fits in a recipe. Those DO go to the dark factory.

And there are brick-oven pizzas.

You feel it when someone cooks them by hand. Takes their time. Watches the temperature. Measures. Understands the fire. Creates an experience the belt can't copy. The flavor is different. The customer notices.

Same thing with code.

There are things you cannot swap for an agent. The human TOUCH is what changes the product. Those extra brushstrokes only we know: how the person is going to interact with the system. Where they get stuck. What gives them confidence. What scares them. The detail that isn't in the ticket, and if you skip it, the pizza comes out "fine" and nobody orders it again.

The machine cooks volume. The brick oven cooks judgment.

If you put both in the same oven, you burn the one that mattered.

The third rule: the pizza goes in right. Someone catches it at the back.

The golden rule still holds: automate what moves the bank account. At Apunto that's the bug → fix → production cycle. Every hour a forwarder waits for a fix is money sitting still.

The second rule too: someone has to let go of the old process. First and last name. A date.

In a dark factory there's a third. Actually two, and both hurt.

1. The pizza that goes in. The PRD. The order. What gets built, for whom, why, and what "done" looks like. If it's loose, the machine doesn't "complete the thought." It bakes the hole. That's why Olivia is at the oven door: she reviews PRDs, prioritizes, and doesn't let a half-order through.
2. Who catches it at the back. Developer and QA. Fígaro pulls the pizza from the oven —the PR— and Luna flips it: did the process move well? Did nothing break? If it fails three times, it leaves the machine and we catch it. REVIEW BY HUMAN. Because there are pizzas the oven should not serve.

YOU no longer assemble every pizza by hand. You decide which one goes in the oven. And behind there's a team with gloves on. Not a single person.

We're not in the 3 a.m. diff. We're in two places: the recipe that goes in, and the window on the way out.

Five in the kitchen. Four on the floor.

The oven does not replace tech. We're four people in Apunto tech. The five agents are not more developers. They're stations. Counter, oven door, oven, window, table. We assemble the pizza and we catch it at the back.

The stations, today, fit on a napkin:

• 🧠 Olivia — deputy CEO. Reviews PRDs. Prioritizes bugs. Moves ClickUp. Does not write Apunto code. (If Olivia codes, the line breaks. She doesn't cook. She decides which pizza goes in.)
• 🛠️ Fígaro — the CTO agent. The one in the oven. Takes tickets in PRD READY, REVIEW FAIL, and READY FOR DEVS. Clones the repo into HIS workspace. Develops. Opens the PR. Sends it to the window.
• 🔎 Luna — QA. Catches. Takes QA NEED REVIEW. If it fails: REVIEW FAIL, documents it, tells Fígaro. If it passes: REVIEW DONE. If it fails three times: REVIEW BY HUMAN. She doesn't patch. She reports. Did everything move? Did something break?
• 🚀 Dalia — DevOps. Configured. Still off. When she turns on: REVIEW DONE → deploy to production → New Relic → DONE. If it blows: rollback and incident. The one who takes the box to the table. Hasn't made her shift yet.
• 💬 Betty — The counter. Takes customer orders in Chatwoot. Customer support is always the voice of the customer: if the pizza comes out bad, the customer doesn't talk to the oven. They talk to her. She doesn't cook. She brings the order.

And us. Four humans in tech. Recipes, architecture, the "this one doesn't get served." If the PRD comes out of a single head, or if one person catches every pizza, the oven doesn't scale. It just gets busy.

A bug shouldn't ask your permission to move

This is how a bug runs when it has the darkfactory tag:

1. It enters ClickUp. The order. A lot of the time Betty brought it: the customer's voice, written down.
2. Olivia looks at the raw pizza. Severity. If it's ready, READY FOR DEVS. Into the oven.
3. Fígaro cooks it. Opens a PR. Moves it to QA NEED REVIEW. To the window.
4. Luna catches it. Did the process move? Did nothing break?
5. If it passes: REVIEW DONE. Dalia, the day she turns on, serves it. DONE.
6. If it fails: REVIEW FAIL. Back to the oven. Fígaro. No drama. No meeting. No "who's taking this?"

A feature is the same hallway, with more recipe at the start. The PRD. Olivia moves it to PRD READY only if it can be cooked. The rest of the team already knows what to do.

The handoff is the product. If the pizza doesn't change owners on its own —from the tray to the oven, from the oven to the window— you don't have a factory. You have a WhatsApp group with expensive models.

OpenClaw is not the magic. It's the oven.

The recipe, today, is not a 40-page PDF:

• A dedicated server. Monterrey.
• OpenClaw 2.0 running the agents.
• Each agent with ITS model. Some use Kimi K2.7 Code. Others use Opus 5 for planning. The model backs how they work and the ruleset that goes with it. Each model is good at something. Not all of them in the same oven.
• ClickUp as the belt. GitHub for the PRs. Each agent with its workspace and its memory.

That's the floor. The process is what keeps it from catching fire: PRD quality before it goes in, mandatory QA before you serve, and four humans on the decisions that actually hurt.

It's not "leave the repo alone and pray." It's: prep the pizza well, let the oven cook, put it in the box, get the exit ready… and NOW, to the window. A hungry customer. They want to see an improvement. Or the error corrected. Not an experiment. A pizza you can serve.

This is the START of the factory. Every factory starts with one line. One. Development. Code pizzas.

Little by little we'll figure out how teams can use this idea for other functions. Customer support. Sales. Product. Another line. Another oven. Same recipe: a clear order, a handoff, someone who catches, maintenance.

Today you turn one on. Tomorrow the kitchen grows.

💡 The question

What process could you start understanding tomorrow?

Don't build the factory yet.

First look at what you can start automating. How it actually works. The people. The processes. Not the wiki flow. The one they use when the wiki is lying.

When you can see it, THEN think about that production line. A real order. A customer at the window.

And if it fails —it will fail— remember: a factory needs a lot of calibration. A lot of work. It doesn't run at full speed on day one.

Start slow. Start with good questions.

But start.

Tell me. Write me or on LinkedIn. It's always a pleasure to talk with that chef who's cooking new recipes, new products. The one who's hungry to build. And to make pizza. 🐭👨‍🍳🍅

If you're stuck between "I want agents" and "we're still the ones coding at 11," let's talk. Most of the time the problem isn't the oven. It's the pizza you put in. Or that only one person was at the back to catch it.