The setup I use to ship while I sleep — now open-sourced

I was the bottleneck

For a long time I was the slowest part of my own work.

Everything ran through one window. One conversation, one me. I would have three good ideas and they would queue up behind whatever I happened to be typing. The tool in front of me was fast. I was the line it had to wait in.

So I changed the shape of the job. Instead of doing the work, I started directing it. I stay in one seat and advise. The actual building happens somewhere else, in the background, handled by workers I hand tasks to and check on later. It runs whether I am at the desk or asleep.

That last part is the honest claim, and I want to be careful with it. This is not ten times faster. It does not replace anyone. It removes one specific problem: me being the single point that everything has to pass through.

I packaged the setup and open-sourced it. It is called ARI-OS. The rest of this is what it actually does.

The part people get wrong

The model is not the intelligence. The system around it is.

A good model with no system is a brilliant person you interrupt every thirty seconds.

The leverage is not in the answer the model gives you. It is in how the work gets framed, handed over, tracked, and brought back. Build that scaffolding once and the same model does noticeably better work, because you have stopped making it start from nothing every single time.

ARI-OS is that scaffolding. A few plain pieces, each doing one job.

• An advisor seat. Your main session stays for thinking and deciding, not grinding through the work itself.
• Background dispatch. You hand a defined task to a cheaper worker that runs on its own, detached from your session.
• A handoff layer. Context survives when a session ends, so the next one starts cold without losing the thread.
• A memory. The setup remembers across sessions and pulls the right past context back when you need it, so you are not re-explaining yourself every time.
• Spec-first brainstorming. You shape the outcome in plain language before any code gets written.
• A small dashboard. One glance shows what is running, what finished, and what is stuck waiting on you.

None of these are clever on their own. Put together, they change who has to be in the room for work to move.

Take the part that does the most quiet work: context. A model with nothing in front of it gives you a confident guess. The same model, handed the right briefs and past decisions, gives you a researched answer. Try it.

The memory

For a long time the setup forgot everything the moment a session ended. Every new conversation started from nothing.

So I gave it a memory. A small brain that lives on your own machine. You write to it, you read from it, and what you keep is still there next session, and the one after that.

Two things make it more than a notes file.

It tunnels. By default it pulls only what is close to what you are doing now, not your whole history. Narrow on purpose. If it senses you might need to look wider, it offers, and waits for a yes. It never widens the search on its own. You decide how far it reaches.

It wanders. Every so often it surfaces one memory from outside whatever you are buried in. Deep focus forgets to look up, so the setup looks up for you, then hands the thread back.

It keeps a rhythm. At the start of a day it hands me back what I was in the middle of, the threads still open, and a sensible place to begin. At the end it tidies itself, notes what got decided, and leaves a short line for tomorrow. I open the laptop already oriented, instead of spending the first twenty minutes remembering where I was.

It is not limited to text either. Point it at a recording or a piece of footage and it can turn that into something it remembers too, so a conversation or a rough cut is not gone the moment it ends.

None of this thinks for you. It remembers, and it puts the right things in front of you at the right time. You still decide what they mean. AI accelerates, it does not generate.

The receipt

Here is the part that earns the title.

I built a chunk of ARI-OS using ARI-OS.

I specced a tool I wanted. I handed it to a background worker. I went to bed. In the morning the tool existed, its tests were green, and there was one question waiting for me about a naming choice. I answered the question. That was my whole contribution overnight.

That is the receipt. The setup was complete enough to extend itself while I was not there. Nothing magic happened. The work simply did not need me sitting in the chair for it to move forward.

The loop

The whole thing is one loop. Six steps, and you can learn it in an afternoon.

1. Brainstorm. Talk the idea out until it is a clear outcome, not a vague wish.
2. Plan. Turn that outcome into ordered steps.
3. Dispatch. Hand a step to a background worker and let it run.
4. Watch. Glance at the dashboard. See progress. See what is blocked.
5. Review. Read what came back. Keep it, or send it back with notes.
6. Ship. Merge the work that passed.

You live on steps one, five, and six. The judgement steps. The machine takes three and four. Step two is shared.

That division is the whole point. The parts that need you are the parts where taste and judgement matter. The parts that do not need you stop waiting for you.

Dispatch is the step that does the heavy lifting. One idea fans out into workers that run in parallel, feed into each other, and arrive as something you can review. Have a play with it.

Try it

ARI-OS is open-source and installs with one command. It sits on top of an existing Claude Code setup, and it is reversible, so you can take it off cleanly if it is not for you.

If you have ever felt like the bottleneck in your own work, this is the thing I built to stop being one.

Get ARI-OS and view it on GitHub.