I Built a System That Runs My Solo App Business Almost by Itself

I run 8 live iOS apps by myself. Most days I don’t touch a text editor. An always-on system of AI agents writes the code, catches its own bugs, schedules its own posts, and pulls its own metrics. I still make every decision that spends money or goes out the door in public. That split, exactly where it falls, is the whole story.

What does four months of AI agent output look like?

I pulled these numbers straight from git while writing this post, not from a slide:

$ git log --oneline | wc -l
4313
$ git log --reverse --format="%ai %s" | head -1
2026-03-20 20:52:42 -0700 Add centralized marketing platform design spec and research
$ ls scripts/launchd/*.plist | wc -l
74

4,313 commits since the day I started building this, every single one in the repo’s history, not a filtered subset. Four months. 74 separate jobs configured on a scheduler, from pulling App Store revenue to watching for a stalled TikTok upload.

What is an AI agent system for a solo app business?

There’s no single “AI app business bot.” It’s an orchestrator (a Claude instance with the full picture) that delegates to cheaper, narrower agents depending on what the task needs, and a human approval gate sitting between anything the agents build and anything that leaves the building:

Telegram bots (one per app)  ──┐
74 scheduled jobs (launchd)  ──┼──▶  orchestrator (Claude, full context)
Approval taps from my phone  ──┘          │
                                           ├─▶ fast-worker  : mechanical, edits, scaffolding, tests
                                           ├─▶ deep-reasoner : judgment, architecture, "why is this failing"
                                           └─▶ supervisor    : owns a whole chunk, reviews its own workers

The orchestrator and everything it delegates to runs on Claude; research, web search, and bulk content drafts route to Gemini instead. Day to day it’s a two-model system, not something locked to a single vendor.

None of those roles decide what’s allowed to go out the door. That’s a separate, much simpler rule:

App Store builds, submissions, keyword changes, and screenshot updates ship autonomously now, I gave that standing authorization in June. TikTok posts and ad spend still wait for a tap in an internal dashboard I built for this, which I just call the board.

How much money does an AI-run 8-app portfolio make?

The 8 apps together bring in roughly $50 a month.

Not $50k. Fifty dollars. I’m not going to break that down app by app, because the honest portfolio-level number matters more than a spreadsheet that makes it look more sophisticated than it is. A system this automated, making less than a part-time minimum-wage shift, is where things stand right now, and I’d rather a reader see that gap than a polished number that hides it.

The bet isn’t that this makes money today. It’s that the marginal cost of trying app #9, #10, #11 keeps dropping while the system compounds, and eventually one of them breaks out. The portfolio-not-kill-switch policy (nothing ever gets pulled from the App Store, apps just get dialed up or down) exists because of that bet, not despite the small number.

There’s a second bet under that one. Building the app isn’t the hard part anymore, AI-assisted iOS development made that the easy 20%. What I’m actually spending my time learning now is the other 80%: marketing, content, positioning, sales, the parts that don’t compress the same way code does, and the parts I want to be able to run myself, which is what limits how many apps I take on at once. I’m building a machine that manages the machine, and that skill holds its value whether or not any single app in the portfolio ever breaks out.

How do you work with an AI agent system day to day?

Three things carry the weight:

Model tiering. The orchestrator is the expensive model. Almost nothing it does is worth doing itself. A rename or a scaffolding task goes to a cheap, fast model. A confusing bug or an architecture call goes to the most capable model available, in total isolation, and comes back with a conclusion, not a transcript. The rule I actually follow: pick the cheapest model that can do the task correctly, and escalate only for judgment.

A memory system that writes itself. 296 files right now, one per lesson: a bug I hit, a correction I gave the agent, a fact about how one of the apps’ analytics actually works versus how I assumed it worked. Every session reads the index before it starts and writes to it when something surprising happens. The system gets less wrong over time not because a model improved, but because it stopped forgetting.

Review loops, not trust. Nothing an implementer agent writes ships without a second, fresh agent reviewing it for spec compliance and quality before a human ever sees it. That’s most of what makes autonomous shipping safe enough to authorize in the first place, though it’s not the only check: a metric that looks off gets cross-checked against a second data source before anyone acts on it.

What breaks when AI agents run your business?

The individual code bugs matter less than the structural walls. Four keep showing up.

TikTok won’t let this run itself, full stop. Every post lands as a private draft; I still open my phone and tap publish, for every app, every time. That’s not a caution I added on top, it’s the platform, there’s no automation path around it that doesn’t risk the accounts. Full autonomy stops one step before the finish line no matter how good everything upstream of it gets.

The content pipeline isn’t even across the portfolio. Two apps have a real script-to-video system: a formula library, a voiceover playbook, all of it. The other six don’t, because building that per app is real work and I’ve only gotten to the apps that earned it first. “The system makes content” is one sentence, but it’s true for a couple of apps and still aspirational for the rest.

Telegram stopped scaling as a decision surface before the code did. Eight bots messaging me at all hours doesn’t give you one place to see what’s actually waiting on a decision. I built an internal dashboard, I call it the board, because a chat interface alone couldn’t hold a portfolio this size once it grew past a handful of apps.

Context drift is the hardest recurring bug, and it’s not in any codebase. An agent that doesn’t know a decision was already made, or already rejected, proposes it again. A persistent memory system and a per-project instruction file help, but they go stale unless something forces them to stay current, so one file gets rewritten fresh every day specifically so a new agent session starting cold still sees today’s system, not a two-week-old snapshot of it.

What can’t AI agents do without a human?

Same rule, applied to the actions that come up week to week:

Most of what’s in the “ships on its own” column isn’t a one-off judgment call, it’s the output of a standing experiment. ASO keyword changes, pricing tests, content-format tests all run continuously, log their own results, and decide on their own whether to push the next change or wait for more data before touching that lever again.

One row is missing from that table on purpose: killing an app. It’s not gated, it’s just not a move this system has. Apps get tiered up or down, never deleted, on the bet that the cost of leaving something running quietly is lower than the cost of being wrong about which one breaks out. This post is a live example of the gate itself: it’s sitting in the review dashboard right now, not published, next to a rebuilt version of this website that also hasn’t gone live. One tap turns both on at the same time.

I built that gate because a broken build and a broken decision cost completely different amounts, and only one of them is worth automating away. If you’re building something similar, here’s the actual test I run before letting an agent act without me, copy it directly:

More of this is coming, one app’s bug story at a time, no fixed schedule. I write when something’s worth telling.