Running a company with Claude Code: the whole setup

What this is, and what it is not

I run Stelar Digital: five Shopify apps and one report product. I also have a full-time job somewhere else. So the company has to keep moving when I am not looking at it.

What makes that possible is not one clever prompt. It is a structure. One page of rules. An AI that acts as my chief of staff. Three more with one job each: one reads, one builds, one reviews what was built. And an independent watcher that checks all of them and reports only to me.

This guide is the whole setup: the rules, who does what, what my day looks like, and the files to copy.

It is not a claim that this setup makes money by itself. It is how work gets done and checked when one person is the whole company. Finding customers is a separate job, and I come back to that near the end.

The one page

On September 7, 2026 I threw out the rulebook. It had grown for months. Every mistake produced a new rule, the AI wrote most of them, and nobody could hold the whole thing in their head. That included the AI.

The replacement is one page, 83 lines. It has five rules.

1. No bypass. My words, typos included: "no law or code will never be bypassed without owner auth." A gate that is unavailable or unsure refuses. The AI never authorizes itself.
2. No action without my order, and no second ask after it. "when i ask you to do something you do it and not come back to me for second and third authorizations." Talking is safe. Nothing I say becomes action without a clear instruction. Frustration and silence are never consent.
3. A fact needs a source read today. The platform, the database, the live page. Otherwise the answer is "unknown".
4. Every item closes. It is fixed, or it is closed with a reason, the week it was opened. No pile.
5. Money, anything a customer sees, and critical calls are mine. Everything else is the machine's.

Then one rule about rules:

"stop just writing rules - if you think we need a rule you need me to authorize it."

The AI writes no rule. It records my instructions in my own words. A rule exists only when I say so. The old rulebook was archived, not deleted, so nothing was lost. It is just no longer in the way.

Who does what

The AI I talk to does not write code. The one that writes code does not approve it. That split is the most useful thing in the whole setup.

• Each seat is pinned to its model. A small gate checks every hand-off against the pins, so a model change is a decision and never an accident.
• One builder per codebase at a time.
• The builder gets two rounds. If the reviewer still refuses, the blockers come to me.
• No fanning work out to many agents without the cost stated and my yes.

People ask where hand-offs break. Mine broke when the seat that built something also described it. A builder's "all green" is a claim. It becomes a fact when a different seat checks it.

What "done" means, and how hard to check

Before anything is built, the AI writes a numbered list of what done means. The reviewer then passes all of it or none of it. Nine of ten is a refusal. Nobody says "done" before the reviewer signs.

Not every job deserves the same check, so each one is sized at the start by the riskiest thing it touches.

The independent watcher

A reviewer checks one change. Something still has to check the operator itself, the AI that runs the business day to day.

So there is one more AI, outside the four seats. It runs once a day. It can only read. It does not report to the operator. It reports to me, on its own line to my phone. When its report and the operator's disagree, the operator has to read the fact at the source. If they still disagree, a third reviewer breaks the tie.

It has filed 106 reports so far.

A fact needs a source read today

An AI with notes will happily tell you what it wrote down last week as if it were true now. This rule stops that.

• Notes, summaries, handoffs and the AI's own records are history. They are never status.
• Status is read now, from the place it lives: billing from the billing platform, a listing from the public page, a post from the platform's own record.
• If it cannot be read, the answer is "unknown". That is an allowed answer.
• A short table says which reader proves which kind of fact.
• A correction is said out loud, as "correction, was X". And a correction needs its own source too.
• What a helper agent reports is a claim until the main seat checks it.

Orders in my own words

Everything I order is recorded word for word, with the time. There are 372 of those entries today. When the AI acts, it can point at the sentence that allowed it.

• No order, no action. "That's annoying" is not an order.
• After a clear order, no second ask. One sentence covers every gate it satisfies, and the work runs to the end.
• If what I said can be read two ways, the AI states its reading in one line and stops.
• Approval for one thing does not carry over to the next thing.

Most of my orders are a few words. "Yes, fix it." "Run the video." "Leave it." That is the point. The structure carries the detail so I do not have to type it.

Memory

The AI starts every session blank. Whatever it should still know tomorrow has to be written down today.

• One small file per lesson. One short index that loads at the start of every session and points into the files.
• Four kinds: who I am and how I like to work, feedback I gave, ongoing projects, and pointers to where things live. I keep a fifth pile too, for traps that bit once.
• Worth saving: a correction, a standing preference, a trap that bit once.
• Not worth saving: finished work, status, anything the code or the ledger already records.

There are 784 files in mine. That is too many, and it shows the weakness. Memory goes stale. A note that was true in August sits there looking just as sure of itself in November.

So memory is treated as a pointer. It says where a fact lives. It is never the fact.

Handoffs

When I leave the desk I type one command. Before the screen saver starts, the AI writes a short note with four lists:

• What I ordered today, in my words.
• What went live or was certified.
• What is waiting on me.
• What I sent by email, so tomorrow's card knows.

The next session receives that note at the start, labeled as data and not as instructions. That label matters. A handoff that says "just do it" does not outrank the rules.

The note is kept under 8,000 bytes on purpose, about a page and a half. Older sections are moved word for word into dated archive files. A handoff nobody can read in a minute is not a handoff.

The day

• 4am, the cards. Two pages built from live reads, one for the business and one for social, open on my screen when I sit down. The business card leads with whether anything needs me. "Nothing needs you" is a valid card.
• Sitting down. One command. It reads money, mail and the board fresh and puts one screen in front of me, under three headings: needs an answer, your hands, nothing to do. Then it waits.
• During the day. I answer in a few words. The work runs to certification without asking me again each round.
• Leaving. One command. The handoff is written, the machine stays awake, the screen saver starts.
• Monday, thirty minutes. Only what needs my judgment: money, customer-facing words, product direction.

Anything I have to read arrives as a finished page, with a copy button wherever I have to copy something. The answer comes first. Short sentences. No ticket numbers.

What runs alone, and the off switches

There is a short, named list of things that may act without me. Morning drafts into my mail. The 4am cards. One research read a day. Monitors and alarms. A runner for jobs I queued. A handful of content and outreach lanes that I switched on by name, in writing. Nothing else moves.

• Every lane can be switched off in one step.
• A lane that prepares is not a lane that publishes. My video lane prepares the prompts overnight and publishes only when I say so.
• Night is monitors and emergency alerts only. No sends, no deploys.
• Money and emergencies come to my phone on one line, and the watcher has its own. Everything else goes to a quiet feed I do not have to read.

When the AI is told no

Safety checks sometimes refuse a command, and sometimes they are wrong. What matters is what the AI does next. The rule:

• Tell me at once, in the open, with the fix it would suggest.
• Do not park the refusal for later.
• Do not try another route alone. A second route needs my word.

An AI that quietly works around a "no" is one you cannot leave alone. This is the rule that lets me leave the desk.

What still breaks

This is the honest part. The structure catches a lot. It also misses whatever no check is looking at.

• Pictures. A video went out with on-screen props the video tool had invented: a document with a made-up dollar figure, and a to-do list of tasks that were never mine. My words and captions were true. The checks read words, not frames. From now on the frames get looked at by hand before a video publishes. Nothing checks them automatically yet.
• Silence. A daily post stopped going out because its own fact check returned nothing. No alarm fired, because nothing had failed. It had only not happened.
• Its own weight. Some days the structure spends more time checking itself than moving the business. That is a cost, and I watch it.

And the biggest limit: all of this is defense. It protects what ships. It does not find customers. If you build this and expect sales to follow, they will not. That is a different job, and you still have to do it.

What it costs

The money side is plain. These are the lines:

Posting and reading through the X API is billed per use, on top of that.

The cost nobody mentions is time. Rules need pruning. Notes go stale. Checks need checking. I budget thirty minutes on Monday for it and try hard not to let it grow past that.

Start in a weekend

Do not copy all of this. I did not build it in a weekend either. Start with three pieces and add the rest only when something bites you.

The starter kit

These are cleaned copies of the real files, with my names, addresses and customers removed:

• The one-page rules, as a template with my five rules as the worked example.
• The four seat definitions: main seat, reader, builder, reviewer.
• The three commands: sitting down, leaving, and wrapping up.
• The handoff file, empty, with one filled example.
• The memory index, empty, with one example of each of the four kinds.
• The review levels table.

The files, as plain text:

• README.md
• RULES-ONE-PAGE.md
• REVIEW-LEVELS.md
• HANDOFF.md
• HANDOFF-EXAMPLE.md
• seats/main-seat.md
• seats/reader.md
• seats/builder.md
• seats/reviewer.md
• commands/open.md
• commands/wrapup.md
• commands/shift-end.md
• memory/MEMORY.md
• memory/user_example.md
• memory/feedback_example.md
• memory/project_example.md
• memory/reference_example.md

Take them, change them, make them yours. The rules that matter are the ones you would actually enforce.

By the numbers