~/arnaud.rocks

$ cat blog/dont-buy-a-code-factory-assemble-one.md

Don't buy a code factory, assemble one

· also on LinkedIn

About a year ago, my AI workflow was opening a Claude instance and talking to it. That’s it.

Then we started rebuilding the way we code and ship at Teetsh from scratch. We’re still at it. I’ve changed my workflow a dozen times this year, probably more. Some setups lived a month. Some barely outlived the next big change by a couple of weeks. And that’s fine.

Now everyone’s talking about code factories. High-level orchestration, fleets of agents, tickets in, pull requests out. I’ve looked at what’s on sale. We built one internally too. It’s maintained, and our CEO and others use it every day. I never really adopted it.

I’ve been thinking about why. My take: we’re putting very different things in the same box, and calling the box a factory.

The black box problem

The first few times I tried one of these tools, it went like this: the agent asked me a few questions, disappeared for a while, and came back with a result.

Maybe it was just an impression. Maybe it was the UI. To be fair, the chat bots I use today also go away and come back. But back then, I couldn’t easily dig into what had been done. The code was written somewhere that wasn’t mine: not my machine, not my localhost, not my terminal. Every tool had a cut somewhere, and past that cut, going deeper was either impossible or tedious enough that I gave up.

In July I wrote that not reading the code is nothing new. I still believe it. But there’s a catch I didn’t spell out: I’m fine not reading the code because I can read it, any time, in seconds.

Trust doesn’t come from looking. It comes from knowing you can look.

There was a second reason, and it’s the same one in disguise: I hadn’t built it. The box was handed to me, finished. I couldn’t open it, and I hadn’t put it together, so I had no way to earn my own trust in it. Being able to dig in and having assembled the thing yourself are two roads to the same place.

The factory You ticket somewhere remote ? the cut × zoom in PR you see what goes in and what comes out The workshop You ticket my machine orchestration · bots agent · Claude Code worktree · localhost code · line 42 zoom in PR every layer opens, down to the line
Same ticket, same PR. The difference is whether you can open the box.

Hand me a black box and tell me “trust me, bro”, and it won’t work. I’d rather assemble it myself.

So I assembled it

That’s pretty much what I did all year. One brick at a time, each step checked by hand before I let it run on its own. Skills, tests, hooks, worktrees, a release train.

It’s how I ended up on Orca, first with plain worktrees. It stayed close to the code. I never felt blind. I could dogfood everything and use my own skills.

There was still friction though. I spent a bit too much time managing worktrees myself. Even with skills that opened one and started Claude on a new piece of work, it was still a bit manual.

And keeping track was just as hard. Which topics were in flight, which ones were waiting on me, and in which worktree and which conversation each one lived. With a dozen things going in parallel, I was the index, and I kept losing entries.

Then I tried Orca’s bots, and two things clicked.

Worktrees went away. The bots manage them. Worktrees and branches are hidden at exactly the right level. I talk about the work, the bot handles where it lives. And when I want to dig in, it’s right there on my machine: a normal worktree I can open, run, and break.

The bots keep track. My previous setup was mostly one Claude conversation per project. Simple, mostly working. The bots handle ongoing tasks and topics much better. The granularity feels right. What needs me is clearly sorted, and when I have to answer a question, I get the exact context with it.

I was already juggling a lot of topics in parallel. Now it takes a lot less fiddling.

And under the hood, it’s still the same low-level stuff: git, worktrees, terminals, Claude Code. Cheap, boring, and mine.

What my day looks like now

I’ve stopped worrying about losing sight. The agents pull me in for what matters. Everything that can run without me just runs. I don’t feel like anything critical happens without supervision, and I don’t feel like I answer questions for nothing.

Part of that is a year of tailoring. The skills we wrote, the workflows I rebuilt, what my agents remember. We used to call that experience.

So my job is mostly expressing needs: what to build next, what to fix next. That works just as well at a high level as at a low level.

Say I ask for a full feature. Most of it I leave open. But if one detail matters to me, I pin it: “By the way, while you’re at it, build this part like this.” Or “this is a choice I want to make myself.”

That’s the real skill: give everything that matters, and only what matters. Whatever you leave out, you’re saying you don’t care how it’s done. That’s how you take yourself out of the loop: make sure the agent has what it needs to build your vision, and let go of the rest.

What if something you let go comes back wrong? That’s experience too. You learn, and you put the lesson in a skill.

In practice it barely happens. We have tests, metrics, observability, and a release process with A/B testing and dogfooding. A small bug in production is still a bug. But if it’s not critical and you can fix it in under an hour, it’s fine. Fixes being cheap is what makes letting go safe.

Harness and factory are not the same thing

Here’s the part I think isn’t discussed enough.

People talk about harnesses and factories as if they were one big thing. They’re not, and I think it matters to split them.

My bots are personal. They’re how I like to work. My teammates work differently, and I don’t want them to adopt my setup.

I learned that one from both sides.

I’ve been on the receiving end: handed a workflow someone else had built and trusted, and expected to trust it too. I couldn’t, not right away. I hadn’t built that trust myself.

And I’ve done it to others. At some point I told friends and teammates: “Here’s the skill I use to orchestrate my work. It just works.” It didn’t really work for them. It was good inspiration, but they couldn’t use it the way I did. They had to build their own trust, and that takes time.

You can show people how you work. You can’t force-feed it. Trust in a workflow is built by the person using it, one checked step at a time, the same way I built mine.

What is shared is what lives in our codebase:

  • the tests and the checks
  • our markdown docs
  • guidelines for design, technical choices, and safety
  • a review process with separate reviews for safety, security, and how things are built

That’s the harness. And I insist: it has to be tied to the codebase, not to the tooling around it. Making sure our repo has all of that is probably the most important thing I worked on this year.

Five layers

The words aren’t settled. “Harness” already means something else: Anthropic calls Claude Code itself an agent harness. Concepts rise, die, and change meaning every few months. That’s expected at this pace. So here’s how I split it, at least for now:

SHARED AT THE TOP AND BOTTOM, PERSONAL IN THE MIDDLE STRATEGY goals · projects · who owns what · updates ↕ MCP↕ MCP↕ MCP ORCHESTRATION mebots, worktrees a teammatetheir own way marketingnothing like mine PRODUCT HARNESS design · safety · security review · release train · A/B CODING HARNESS tests · lint · checks · code guidelines · build review AGENT HARNESS Claude Code · Codex · … sharedcompany personalper person ← stays sharp sharedin the repo your pickswappable
The line between the two harnesses is blurry. The one under orchestration isn't.

The line between the two harnesses is blurry. A security review is about code and about product. That’s fine. The line that has to stay sharp is the one under orchestration: everything below it belongs to the team and lives in the repo. Everything above it, up to strategy, is yours.

So it’s shared at the top and bottom, and personal in the middle. The company agrees on where it’s going (strategy) and on how quality is guaranteed (the harness). How each person gets from one to the other is up to them.

The single vertical is an illusion

The strategy layer is the next problem I’m looking at. You need a company-wide view of where things stand: goals, projects, responsibilities. We used Linear projects for that. When we stopped using Linear for issues, we rebuilt it inside our internal tool.

But I think it should be its own brick. People contribute to it, and maybe agents one day: they move topics forward and post updates toward a goal. It should work on its own and plug into everything else through MCP or whatever comes next.

Trying to build one vertical from the codebase all the way up to strategy is an illusion. Here’s a simple test: marketing. One vertical means your orchestration layer has to work just as well for a marketer as for a developer. It won’t. Their middle layer looks nothing like mine, and it shouldn’t.

You need the vision across the company. You don’t need one tool to carry it.

Everything has to be swappable and interoperable

Today I love Claude Code. Tomorrow, I don’t know. Today I love Orca. Tomorrow, I don’t know.

So every piece of the puzzle has to be replaceable, and interoperable: it has to talk to the others through open, boring interfaces (git, files, MCP) so you can pull one out without breaking the rest. And the shape of the puzzle changes too, because the tech moves, the ecosystem moves, and we get new ideas every day about how to build things.

If you want to keep the word “factory”, fine. But it’s not a black box. It’s an assembly you can take apart. Think about your problems layer by layer, and keep the freedom to change how you solve each one.

That’s also why the harness belongs in the repo, and why it’s mostly written for agents. Markdown guidelines, tests, and checks are plain files any agent can read. Swap Claude Code, swap Orca, swap the whole orchestration layer: the harness stays. The experience you committed stays. A new teammate, human or agent, inherits it on day one.

Some layers churn every few weeks. Some last for years. Put what must last where no tool can take it away.

ONE YEAR, FOUR LIFESPANS strategy Linear projects internal tool orchestration a dozen rebuilds, some lived two weeks agent harness Claude Code, so far harness (repo) never restarted, keeps growing a year agotoday
Schematic, not to scale. The tools churn. What's committed to the repo stays.

A year ago I was starting Claude instances by hand. Today agents run agents for me. Next year it’ll probably look different again.

Don’t buy a factory. Assemble one, and keep the parts you can’t lose in the repo.

cd ../