How one main Claude chat coordinates my 2 YouTube channels, 5 social platforms and 3 SEO projects

A to Z guide with real numbers from my own board on 17 Oct 2026.

I stopped trying a new terminal every week. My work runs in the Claude desktop app, with the Codex CLI behind it for reviews. One main chat coordinates the rest.

This guide covers what runs where, how state is kept, how code gets merged, how posts go out and what I still approve. It ends with one real job from start to finish.

Here is what my board showed at 16:24 today:

• 66 jobs
• 195 chats
• 2 YouTube channels (DAINER AI and Rise & Fall Files)
• 5 social platforms (X, Threads, Instagram, Facebook, LinkedIn)
• 3 SEO/AIO projects

The costs on the board are API-equivalent. Those estimates are not charges on my bills. I'm on flat plans (Claude Max and a ChatGPT plan with Codex), and the board shows what the same work would cost at API list prices.

Before you start

You need four things:

1. The Claude desktop app with Claude Code. I'm on Claude Max.
2. The Codex CLI. It comes with a ChatGPT plan.
3. Chrome with the Claude in Chrome extension, logged in to your own accounts, if you want it to post for you.
4. One project folder on your computer where all the files below live.

A. One main chat, many directors

My main chat is CLAUDEX, my HQ. It doesn't do the work. It hands jobs to director chats, chases the stuck ones and confirms live URLs.

Each director chat owns one lane:

• Static Content Director: Posts for the 5 platforms
• Content Creative Director: DAINER AI videos
• Rise & Fall Files: The second YouTube channel
• SEO/AIO Director: The 3 SEO projects
• DAINER.AI Website: The site and its library

HQ sends a director a short message: new job, the inputs, the gate. The director does the job and sends one line back. In the Claude desktop app, chats can message each other directly. That's how HQ reaches me in the posting chat.

The messages are just nudges. The state lives in files, so if a chat dies, a new one reads the files and carries on.

B. Memory and state

Five kinds of files keep it straight.

1. TODO.md. One short entry per lane, with what's happening now and the next action. History goes to dated logs, not here.

2. Job cards. One small JSON file per job, in dispatch/jobs/. The board reads these. A card looks like this:

{
 "id": "OC2-20261019",
 "title": "Own-content batch 2",
 "lane": "STATIC",
 "status": "active",
 "steps": [
  {"name": "Pick topics from the radar", "done": true},
  {"name": "Draft", "done": true},
  {"name": "Codex review to PASS", "done": false}
 ],
 "updated": "2026-10-16T00:58:00+08:00"
}

3. Receipts. Every job ends with a receipt in dispatch/receipts/. It lists what was done and the raw evidence. The last line is always one of these:

STATUS: VERIFIED (evidence: ...)
STATUS: UNVERIFIED (cannot test because ...)
STATUS: BROKEN (failure: ... Next step: ...)

"Done" without evidence doesn't count.

4. Handoff packets. Before a chat touches a lot of files, it writes a short packet under memory/session-handoffs/ that declares the job and the files it may change:

JOB_ID: OC2-20261019
ALLOWED_WRITES:
  - work/oc2-20261016/
  - dispatch/jobs/OC2-20261019.json

A guard hook counts edits to code and system files. Once a chat edits more than a few files that aren't declared, the hook blocks the next edit and asks for a packet. This limits undeclared edits made through Claude's edit tools.

5. Claude's auto-memory. Each project has a MEMORY.md index of short notes: my rules, my corrections and pointers to files. A new chat starts with it.

C. Claude writes, Codex checks

The rule I set: Claude owns strategy, voice and writing, and Codex owns technical production and review. In practice Claude still builds small tools too.

• Posts. Claude writes every post. A fresh Codex session reviews it read-only, so it can't change files. On a FAIL, Claude fixes it and a new Codex session reviews again. Nothing is scheduled until it passes.
• SEO and website pages. They go up as pull requests, and Codex reviews each one before anything merges.
• Copy jobs. Codex moves reviewed files into the publish folder and writes checksums, under a short work order.

Both read one shared rulebook. The project's AGENTS.md is loaded by Codex on its own, and Claude pulls it in with one line in CLAUDE.md: @AGENTS.md. My writing guide is one folder that both read through a symlink, so the rule I edit is the same rule for both.

D. Repos: Codex approves, Claude merges

I don't click merge anymore. A scheduled Claude task called the merge steward runs every 2 hours, from 09:15 to 23:15. For pull requests opened by a director chat in my three site repositories, it's set to merge into main only when all of these hold:

• The pull request is open and isn't a draft.
• The latest verdict comment approves the current commit. The reviewer is OpenAI's Codex model, and the review log shows that, not a Claude model.
• At least one check exists, and every required check passes with nothing pending or missing. GitHub reports a clean merge. One repo also runs its tests on a fresh copy first.
• It isn't on the hold list. Right before merging, the steward checks again that it's merging the exact commit Codex approved.

A Claude review can never authorise a merge. Claude can only merge what Codex approved.

After a merge, the steward checks the live site at phone 375, tablet 768 and desktop 1366 and 1920 widths. If a live check fails, the steward opens an issue, and the owning chat makes a fix PR that goes through the same review. I get a one-line notice per merge instead of a request.

E. Scheduled runs and Chrome

Most posting happens while I'm busy. I have 59 scheduled tasks saved in the Claude app, and 32 are posting tasks, past and upcoming.

Each posting run follows a written runbook:

1. Claim the job. It creates a file only one run can create, so a second run of the same job stops.
2. Take the Chrome lock. Only one run may drive Chrome at a time. A run that finds Chrome busy checks again every 5 minutes, and stops once it's 45 minutes past its slot.
3. Check Chrome. If the extension isn't connected, the run opens Chrome, waits 30 seconds and checks again. If it's still down, the run re-arms itself 30 minutes later, at most twice, and notifies me once.
4. Check the fingerprint. Every package has a checksum file. If any file changed after review, the run stops.
5. Check the kill switch. Each batch has a small review page with Fine, Change and Skip. The run reads it before posting and stops if I tapped Skip or Change. If the page can't be read, some runbooks still go ahead, so it's a check, not a guarantee.
6. Post, read back, log. Each platform is checked for an existing copy, posted once and read back. The live URL goes into a log.
7. Clean up. Close every tab it opened, release the lock and write the receipt.

Every posting prompt also quotes my approval word for word from the file it's recorded in. It never invents one.

F. KUMAR: the summary on my phone

I turned off Claude notifications on my phone. Too many pings.

Results and questions for me go into a file in an inbox folder. KUMAR, my assistant in the ChatGPT app, checks that folder every 30 minutes and gives me the summary in its chat. A file only proves it was delivered, so the chats count something as picked up only when KUMAR replies or logs it.

G. The board

The board is a small mod I had Claude build for Claude Code. It shows every job's progress, its next step, how long it has run and its API-equivalent cost. It also shows each chat's total and the latest messages between chats.

It reads the job cards and the Claude and Codex session logs on my Mac. It never changes a job, and it keeps only its own cache. That's where my numbers come from.

H. What I still decide

Here, autonomous means it runs by itself while I approve what matters:

• Money: any new spend.
• Legal: anything with legal weight.
• Posts: every post goes out under an approval of mine that's written down, and each batch has a review page where I can tap Skip before it posts. A new kind of post comes to me first. This one did too.

It also breaks. This week:

• a run found Chrome disconnected
• a safety check stopped a post
• a run couldn't upload images from a folder it wasn't allowed to read
• two runs overlapped in Chrome

None of them posted anything twice. Each one got a new rule in the runbook the same day, and the next runs are the real test of those rules.

I. One job from start to finish

Here is a real one, the OC1a post, "5 Claude Code settings that saved me".

1. 14 Oct: my radar flagged two YouTube videos beating their channel's usual views, both about Claude Code setups. They became the topic.
2. Claude drafted the X thread, the posts for Threads, Instagram, Facebook and LinkedIn, and 7 slides, using our own hooks and logs as proof.
3. Codex reviewed it read-only. First round FAIL. Claude fixed it. The recheck failed on 2 points, Claude fixed those, and the third round passed.
4. A Codex copy job moved the reviewed files into the publish folder and wrote a checksum file.
5. A review page with the kill switch went live, and the post was scheduled for Saturday 11:00.
6. Saturday: the run claimed the job, verified the package fingerprint (955299b6144e), checked 34 of 34 checksums and uploaded from its own copy of the package. Chrome dropped a few times, so it finished about three hours late, between 13:51 and 14:20. It read back all five platforms and logged every URL.

That's the loop. Pick from real data, write, review until it passes, freeze the files, schedule with a kill switch, post and read back.

J. If you want to start

You don't need 195 chats. Start here:

1. One main chat in the Claude app that only hands out and tracks work.
2. One job card per job, with steps you tick.
3. One receipt per job, ending in a STATUS line with real evidence.
4. A second AI to review before anything goes out. I use the Codex CLI, read-only.
5. One schedule. Turn a job you repeat every week into a scheduled task with a written runbook.

Add a board once you have more jobs than you can hold in your head.

Related guides

• AI Work OS: the rules file, board, job hand-offs and receipts this setup grew from, as plain files you can copy.
• Set up a project for Claude Code: memory, permissions and checks before the agent builds anything.
• How to run a social media account with AI: the posting side in more detail.
• How we run two faceless YouTube channels with an AI video factory: the video side.