# I run my whole business from one shared repo and a single Claude "orchestrator" chat. Projects and nested sessions kind of broke my workflow. Am I doing this wrong? — retained record

> Retained reddit record from reddit:ClaudeAI.

Canonical: https://highsignal.app/data/records/653676a8e7d336f1

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:ClaudeAI)  published 2026-10-28 14:43 ingested 2026-10-29 02:37

[original source ↗](https://www.reddit.com/r/ClaudeAI/comments/1xhq021/i_run_my_whole_business_from_one_shared_repo_and/)

## retained text



```
I run a small video production business plus a growing pile of side projects, all through one setup. I haven't found anyone else working quite like this, so either I'm onto something or I've built a very elaborate way to confuse myself. Possibly both.

# The setup

Everything lives in one root folder on a cloud volume mounted on my Windows PC and a Linux box I call the XPS (an old laptop in a closet), where the coding agents run.

The root holds about a dozen project "lanes": my motion graphics engine, branding and strategy for several companies, an AI lab and server stack, bookkeeping and more. Each has its own CLAUDE.md, a current-state file, an inbox for notes from other lanes, and a generated work map. Everything cross-references: the engine renders client videos, billing reads time tracking.

    NFW/
    ├── CLAUDE.md               # read-me-first, shared rules
    ├── OPERATOR_PREFERENCES.md # how agents work, which model for what
    ├── CONTINUITY.md           # every active stream + current state
    ├── _queue/items/*.json     # the ONE task list (~1,100 cards)
    ├── _xps_runs/              # prompts, reports, my messages verbatim
    └── <13 lanes>/             # each with CLAUDE.md + 00_START_HERE/

The queue is the only to-do list. Every work map and my "needs you" list is generated from it, and every message I send is saved word for word.

# How I work

I treat one orchestrator chat like a chief of staff. I dump a voice-to-text wall about five unrelated things (see: this post) and it sorts them into lanes, writes queue cards, and does the work or sends it to the XPS through an MCP gateway I built. That launches Codex or Claude Code sessions in tmux, a dispatcher keeps them running overnight, and a watchdog pokes them when they stall. The orchestrator brings me only the decisions that need me.

***For months that orchestrator was a Claude Cowork chat***, so I had my PC and Chrome while sending dev sessions to the XPS. Long chats handed off to fresh ones, since all the state lives in the repo.

# Where Projects confused me

When **Projects** *(beta)* and nested sessions arrived, I assumed the project chat would become my new orchestrator. Day one:

* **Threads everywhere.** It started a thread for nearly every ask, and each acted like its own little orchestrator, asking me questions behind a yellow dot. I couldn't tell whether to work in the main chat or in each thread.
* **It wasn't oriented.** It told me "nothing is waiting on you" while my queue had 88 cards waiting on me, because it trusted thread reports instead of reading the repo. The main chat also has no connector access (like my XPS Gateway MCP), so it couldn't see the XPS.
* **Memory drifted toward the project.** I asked for a rule about two agents editing one file, and it wrote one into the project instructions. My repo already had that rule, enforced by file locks. That's my biggest worry: once rules live in Claude's project settings instead of the repo, they drift apart and I can't hand orchestration to Codex or whatever's next.
* **My projects are tangled on purpose.** Nested sessions suit isolated tasks. My lanes all depend on each other, so splitting them mostly stranded context.

By the end of day one I was back to one long-running thread as the orchestrator, with the gateway and the queue. Project memory is just pointers into the repo. It works, but it feels like I'm using a brand-new feature to recreate my old setup.

# What I'm asking

* Anyone else running a cross-dependent multi-project setup like this? How do you use Projects and nested sessions, if at all?
* Is one long-lived orchestrator thread with files as memory the right call, or am I fighting the tool?
* How do you keep memory and rules portable between Claude, Codex and whatever's next?
* Anything obviously dumb in the structure? (Be nice. Or don't, it's Reddit.)
```



document fetched 2026-10-29 00:22 · canonical https://reddit.com/r/ClaudeAI/comments/1xhq021/i_run_my_whole_business_from_one_shared_repo_and
