I Built the Org. Then Realized No One Was Actually Working.

I built "Me Inc" as a personal operating system that runs like a firm.

The idea: instead of Claude doing everything in one big conversation, I have a full org chart. CEO routes the brief. COO dispatches it. Departments execute. Specialists deliver.

Here's the structure:

Ariel (Principal)

→ CEO (classifies input, catches escalations, routes work)

→ COO (dispatches to the right department)

→ Delivery (client work, competitions, product builds)

→ Marketing (brand, content, copy, distribution)

→ Finance (cash, capital allocation, deal screening, pricing)

→ Knowledge (research, competitive intelligence, intake routing)

→ Partnerships (B2B relationships, outreach, deal conversion)

→ 20+ Specialists across all departments

Coming soon: Studio, Career

Each layer has CLAUDE.md files with routing rules, escalation gates, handoff formats, and model assignments. Took weeks to build.

What Me Inc. Is and Why It's Built This Way

I'm a solo operator — operations consultant, builder, running a portfolio of projects. When I first started using Claude Code in October last year, I built "Me Inc." as a way of keeping all of that organized, a way of running my life as a company would — and I hit the wall: Claude is powerful, but a single conversation doesn't scale.

Every session started from scratch. Context would bleed between project types. I'd ask for a LinkedIn post and Claude would drag in client project context. I'd ask for a financial decision and get generic advice with no awareness of my actual sovereignty stage or capital position. I'd brief a competition build and the whole history of unrelated work would contaminate the output.

More fundamentally: different work requires different thinking. A pricing decision and a cold outreach draft and a domain research sprint are not the same cognitive task. Routing all three to the same model at the same tier in the same context is like asking your accountant to also write your copy and also do your competitive research — in the same meeting.

The ICM architecture here in Clief Notes showed me what I was missing. "The Team" turned my file system into a personal operating system built on top of Claude Code that runs like a firm:

CEO layer — reads every brief first, catches escalations ($10K+, new entities, external commitments), classifies the work, and routes it. The CEO does not execute.
COO layer — receives the routed brief and dispatches it to the right department with the right context from storage.
Five active departments — Delivery (client work, competitions, product builds), Marketing (brand, content, copy, distribution), Finance (cash, capital allocation, deal screening, pricing), Knowledge (research, competitive intelligence, intake routing), Partnerships (B2B relationships, outreach, deal conversion).
20+ specialists — each department has 3–7 specialists, each with a narrow mandate, their own rules, their own examples, and their own model assignment.

The whole thing lives in a folder structure on disk. Every role is a CLAUDE.md file. Storage is mapped. Handoff formats are defined. There's an escalation gate, a signals inbox, a routing log, and an after-action review protocol.

The reason it's built this way: I'm building toward ownership. I need a system that can hold institutional memory, route work correctly without me orchestrating it manually every time, and get smarter from use, not one that resets to zero every conversation.

That's the design intent. Here's where it broke.

The Problem

After the last competition build (Week 5 "The Coach"), I asked a direct question:

Is THE_TEAM actually being used, or am I just talking to Claude?

The answer was uncomfortable.

All of it — CEO, COO, every department, every specialist — was collapsing into a single conversation window at a single model tier (Sonnet 4.6).

The CLAUDE.md files existed. The routing tables existed. The model assignments existed. But none of it was spinning up actual sub-agents. I was reading instructions and following them inline. The org chart was a document, not a machine.

The org was built. The phones were never wired.

The Fix

Updated 7 files. Added explicit spawn instructions to every orchestration layer.

CEO CLAUDE.md — Execution Protocol added:

When a brief is classified as a Work brief, do not execute it inline. Spawn an Agent:

Agent(

model: opus,

prompt: |

You are the COO of MeInc HQ.

Read /THE_TEAM/CLAUDE.md as your operating instructions first.

Brief: [brief]

Sovereignty stage: [stage]

Return: classification used · department invoked · output or escalation flag.

)

COO CLAUDE.md — Spawn Instructions added: Each department now has an explicit spawn call with model (sonnet— departments route, they don't synthesize).

All 5 department CLAUDE.md files — Model routing tables converted to Spawn Instructions:

Work type | Model

Intake, architecture, diagnosis, deal-closing, research, synthesis | Opus

Commercial, build, quality, distribution, copywriting, execution |Sonnet

Every level now has: (1) the instruction not to execute inline, and (2) a prompt template that hands the brief to the correct sub-agent with the right model.

The Lesson

You can design a perfect system and never actually build it.

The CLAUDE.md files were governance — rules, routing, escalation gates, handoff formats. Well-designed governance. But governance doesn't execute itself.

The execution layer is the part that says: here is the exact command, the exact model, the exact prompt shape — run it now, don't reason about it.

Without that, the system runs on intention. With it, the system runs on instruction.

The difference is whether your org chart is a diagram on the wall or a machine that does work.

Me Inc is my personal operating system built on Claude Code. If you're building something similar, or just trying to get Claude to stop collapsing everything into one context window, happy to compare notes.

3 comments