Claude Code for solo founders running multiple businesses

Three years ago the question of how many businesses one founder could run was roughly settled: the answer was one, possibly two if one was on autopilot. The arithmetic has changed. We run four businesses concurrently — a Shopify kids brand,

Three years ago the question of how many businesses one founder could run was roughly settled: the answer was one, possibly two if one was on autopilot. The arithmetic has changed. We run four businesses concurrently — a Shopify kids brand, a B2B AI agency, a trading-education SaaS, and the studio that houses all of them — and the operating system that holds it together is Claude Code. The claude code workflow that makes the AI agency solo founder model work in practice is not a chat interface, it is a filesystem-aware, repo-native agent with opinions about the shape of your week. This piece is how we structure that week, the files and commands that run it, and the ceiling we still hit.

The shape of the week

Before Claude Code we ran each business in blocks — Monday was Shopify, Tuesday was agency work, and so on. It felt efficient and was not. The context tax of switching from a Shopify PDP bug to a cold-outreach sequence was enormous; the real working-hours multiplier was far below one.

With Claude Code the shape flipped. Blocks got shorter — two-hour sessions, three or four per day — and they became interleavable because the context lives in the repo, not in our heads. A two-hour Shopify session in the morning and a two-hour agency session after lunch no longer feels like two context switches. The repo is the context. We just open a different folder.

Twenty-eight hours per business sounds like a lot. It is not. Most of those hours are the model doing the work with the founder supervising. The old number — fifty-plus hours per business if the founder wrote everything — is what made the multi-business pattern impossible. The new number is why it's not.

One repo per business, one CLAUDE.md per repo

The foundation of the workflow is a single idea: every business has a repo, and every repo has a CLAUDE.md that teaches the model the business. When you run claude inside that repo, the model starts with a few hundred lines of orientation — what the business sells, who the customers are, what the codebase does, which files never to touch, which invariants must hold.

<!-- CLAUDE.md — kids Shopify store, excerpt. -->
 
# Working context
 
You are assisting with the WondraKids Shopify store.
Product category: children's accessories, 2–8 years.
Primary channel: Meta ads → product landing page → checkout.
Stack: Shopify Horizon theme, custom Liquid sections.
 
## Invariants
 
- Never modify files in /assets/third-party/ — vendored and updated via script.
- All new Liquid sections live in /sections/ with a matching preset.
- Price and SKU are owned by the Shopify admin, not the theme. Don't hardcode them.
- Copy changes in English-US only; French/German translations come through
  Shopify's Markets admin.
 
## Style
 
- Liquid over JavaScript when choosing between them.
- Metaobject-driven sections over theme JSON for any content a merchandiser touches.
- No new npm dependencies without asking.

The CLAUDE.md is the single most load-bearing file in the whole workflow. It does three things: it keeps the model from asking the same thing twice across sessions, it gives a new session eighty percent of the context a two-hour warmup would have given us, and it documents us to ourselves when we come back after a week on a different business.

Slash commands for the things that repeat

Claude Code's .claude/commands/ directory is where we store slash commands — named prompts we invoke with /<name>. We have a handful per business and a shared set across all four repos. The recurring-task ones pay for themselves within a week.

<!-- .claude/commands/post-new.md -->
 
Scaffold a new blog post for the bunnyhoneyclub.com studio blog.
 
Ask me for:
- title
- primary keyword
- target batch (A technical, B opinion, C case study, D essay)
- accent color
 
Then:
1. Run `pnpm new-post "<title>" --accent <accent>` and confirm it wrote the MDX.
2. Open the new file and draft a lede matching the batch voice.
3. Stop and show me the lede before writing the rest of the article.

The stopping is the important part. A slash command that runs to completion on the first turn is a command that skipped the review step. Every one of ours stops at a natural checkpoint — after scaffold, after lede, after outline — so the founder is in the loop on the parts that matter. Anything else is how you end up with forty pull requests nobody has read.

<!-- .claude/commands/finance-close.md -->
 
Run the monthly finance close for this business.
 
1. Pull the last month's Stripe, Shopify, and bank transactions from the CSVs in /finance/in/.
2. Reconcile against the chart of accounts in /finance/chart.yaml.
3. Flag anything that doesn't match within 2% tolerance.
4. Write the month's summary to /finance/closes/<YYYY-MM>.md and commit it.
 
Stop before committing and show me the flagged items.

This one runs monthly across all four businesses. A process that used to eat a full Saturday now eats an afternoon, most of which is the founder reviewing a handful of flagged transactions the command surfaces.

Hooks: the part nobody talks about

Claude Code has a feature called hooks — shell commands that run in response to events. We use three of them in every repo:

// .claude/settings.json — excerpt.
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "pnpm typecheck --silent || true" }
        ]
      }
    ],
    "Stop": [
      { "type": "command", "command": "git status --porcelain" }
    ]
  }
}

PostToolUse on Edit|Write runs the typechecker every time Claude writes a file. When the typechecker fails, the failure shows up in Claude's next turn, and the agent fixes the types before moving on. No cycle of "I wrote it, you run it, you paste the error, I fix it." The loop closes itself.

Stop runs git status --porcelain every time the agent finishes a turn, so the final transcript always ends with a clean summary of what changed. When you're running four repos you will lose track of this without the hook; with it, you never do.

The single biggest productivity win from Claude Code isn't the writing. It's that the typechecker runs automatically and the model reads its own errors. The ratio of code shipped to code reviewed by a human doubled.

— our internal review, six weeks in

The persona problem

The hard part of running four businesses in parallel isn't the model — it's the founder. Switching from "marketing copy for children's apparel" to "system design for a trading SaaS" at 11am is a real cognitive tax, and Claude Code doesn't eliminate it. It just turns a fifty-minute warmup into a fifteen-minute one.

We ease the remaining tax with what we call personas. Each business has a persona.md file, read at the start of every session, that sets the voice the founder should be writing in for that business.

<!-- persona.md — WondraKids -->
 
You are writing for parents of 2–8 year olds. Warmth first. Specifics about
durability, safety, and care. Avoid industry jargon. Never condescend. The
parent is exhausted and smarter than you think.

The persona file is the antidote to the subtle bleed-through that happens when you spend the morning writing technical documentation and the afternoon writing product copy. Claude Code reads it; the founder reads it too.

The ceiling we hit

Four is not five. We tried adding a fifth business for a month and it broke. Not because Claude Code couldn't handle it — the repos and slash commands and hooks all scaled — but because the founder's memory gave out. By week three we were mixing up which Postgres schema belonged to which business, which invoice cycle mattered this week, which customer had asked which question. The model stayed sharp; the operator didn't.

The fix at that scale is not more AI. It's a teammate. At five businesses you need an operator, which is the thing you couldn't afford at two. This pattern works for three to four businesses, in our hands, and not above. We'd be skeptical of anyone claiming to run seven.

We've written separately about the specific multi-agent architecture that extends Claude Code beyond the founder's console — the factory pattern where long-running agents take on the kind of recurring work a slash command can't batch. That piece is where the ceiling moves, a little, but the shape of the work it does is different: it's back-office, not frontline. The frontline stays Claude Code, one founder, four businesses, and the discipline of a well-tended CLAUDE.md.