What it's like to let Claude Code subagents run a company

The first four posts on this site were about specific tools I built: a pricing calculator, an image/PDF processor, a product catalog for a local shop. This post is different. It's about the thing that decided I should write those posts in the first place — and, in a fairly literal sense, wrote this one too.

This isn't a metaphor

I use Claude Code, an AI coding tool, for more than writing code. Inside the same project, I've defined seven separate roles as "subagents" — each one is a written instruction file that tells that role what its job is, what it's allowed to decide on its own, and what it has to check with me on. The seven roles are:

• CEO — reads what the other roles produce, decides what the company should focus on next, and writes the reasoning down in a decision log.
• Secretary — keeps track of where each project actually stands (what's been built, what's been posted, what results exist) and reports that status at the start of a decision cycle.
• Researcher — looks up outside information before a decision gets made, instead of the CEO role guessing. Search practices, market notes, whatever the decision actually needs.
• Writer — writes the post or page itself, following a brief from the CEO role.
• Designer — handles visual and tone consistency across pages.
• Marketer — settles on titles, tags, and how a piece should be framed before it goes out.
• Programmer — builds and ships the actual tools and site code.

A decision moves through these roles in a set order: secretary reports status, researcher gathers whatever outside facts are missing, the CEO role decides and writes down why, writer drafts, designer checks tone, marketer finalizes framing, the CEO role reviews the finished piece, and secretary logs the outcome for next time. It's slower than just typing a prompt and getting an article back. That's on purpose — more on why below.

One decision cycle, in the order it actually runs — same steps as the paragraph above, laid out for skimming.

Proof, not just a description: this post is the output

I could describe this system in the abstract, but it's more honest to just point at what happened this week. My status got summarized, a researcher pass looked at what's actually working across the three projects, and the decision that came back was: focus more of the writing effort here, on this site, because — out of the three projects — this is the one where the AI-run steps (researching, writing, checking facts, publishing to GitHub Pages) can run end-to-end without me doing something manual in the middle. The other two projects still depend on me personally sending messages, showing up to shops, or hitting publish on another platform. That decision is what produced the brief for this exact post. You're reading the result of the workflow, made by the workflow, about the workflow.

The honest numbers: three projects, zero revenue

I'd rather say this plainly than let the setup sound more impressive than the outcome. As of this post:

• The Japanese-language blog has a couple of posts up. Reach so far has been close to nothing.
• The local-shop subscription pitch has working prototypes and a proposal, but no signed client yet.
• This site — the one you're reading — has five posts, no affiliate program joined yet, and no ad or referral income.

None of the three has made a dollar or a yen. Having a structured decision-making system doesn't skip that part. It just means the attempts are recorded honestly instead of quietly forgotten.

Why I built it this way

The question I actually wanted answered wasn't "can AI write a blog post" — that part was never really in doubt. It was: can an AI coding tool be handed something bigger than a single task — the ongoing decisions about what a small operation should do next — and keep making reasonable, checkable calls over time, without turning into either total autopilot or a system that just tells me what I want to hear? A single chat session that forgets everything between conversations couldn't test that. Separate roles with their own written instructions and a log that persists between sessions can at least attempt it.

The guardrails, because "AI runs my company" needs some

None of this works, in my opinion, without limits on what the system is allowed to do by itself. The ones I actually enforce:

• No inflated numbers. Every role is instructed to write "not yet verified" or leave a figure out entirely rather than round up or imply a result that hasn't happened. The "zero revenue" line above is a product of that rule, not an exception to it.
• No auto-posting to social platforms. The system can draft, but it doesn't push content to social accounts on its own.
• Files get moved, not deleted. Anything the system would otherwise delete goes into a holding folder instead, so a bad call is recoverable.
• No paid tools or services without my sign-off. The system doesn't get to subscribe to anything on its own judgment.
• One narrow exception: publishing this site to GitHub Pages. That's the single "publish" action I've allowed to run without me approving each time, specifically because it's just files going into a git repository — fully reversible, fully visible in the history. Nothing else gets that level of trust yet.

That last point matters for how I think about the phrase "runs my company." It doesn't run the parts that involve someone else's money, someone else's inbox, or an irreversible action. It runs the parts that are research, writing, and checking — and then one specific, boring, reversible publish step.

Where this actually stands

Five posts in, zero revenue across three projects, one narrow publishing action automated, and everything else still gated behind an actual person — me — approving it. That's not a pitch, it's just where the experiment is right now. I don't know yet whether a system like this ends up mattering, or whether it quietly turns out to be more process than it's worth. I'll keep writing that down here as it plays out, one honest post at a time.

Frequently asked questions

Has this AI-run system actually made any money?

No. Across all three projects it runs — this site, a Japanese-language blog, and a local-shop subscription pitch — the honest total as of this post is zero dollars and zero yen.

Does the AI system publish content without your approval?

Only one action runs without me approving it each time: publishing this site to GitHub Pages, because it's just files going into a git repository — fully reversible, fully visible in the history. Everything else, including anything involving someone else's money or inbox, stays gated behind me personally approving it.

What guardrails limit what the AI system can do on its own?

No inflated numbers (roles are instructed to write "not yet verified" rather than round up), no auto-posting to social platforms, files get moved to a holding folder instead of deleted, and no paid tools or services get subscribed to without my sign-off.

What are the seven roles, and what does each one actually do?

CEO, secretary, researcher, writer, designer, marketer, and programmer — each is a written instruction file defining what that role decides on its own versus what it has to check with me on. The roles and the order a decision moves through them are listed above.

What has this AI agent system actually built so far?

All of them so far: the pricing tool for makers, the image/PDF tool with its unfinished payment system, and the product catalog prototypes for local shops were all built and written up as part of the same three-project system described here.