Shipping Solo

I pitched this as a conference talk. It got rejected, so you're getting it as a post instead.

This year I shipped four apps to the App Store. Naturalis, a nature field guide. AteIQ, an AI calorie tracker. Nozomu, a calm nonogram game. Cascade, a two player card game my son invented. I designed them and built them. One person.

Except that's not really true. I have a team. My team is Claude.

Chat is my strategist. We argue about pricing, paywalls, what to build next, what the analytics actually say. Code is my engineering team. It writes the Swift, runs the builds, opens the PRs. I direct. I review everything. Nothing ships that I haven't read.

Here's what I've learned doing this for a year, and it's not what the AI hype accounts tell you.

The shape of a day

Before I'm up, the team has already been working. At 5am an agent researches the market around each of my apps and posts a brief to Slack. At 6am another one reads yesterday's commits across my repos and drafts build-in-public posts from what actually shipped, so I wake up to material instead of a blank page. Neither of them publishes anything. They prepare, I decide.

Then the day is sessions. I write a brief, hand it to Code, review what comes back, and move to the next one. Strategy questions go to Chat, which has the context of every launch, every pricing debate and every mistake this year. It will tell me when it thinks I'm wrong, because I've asked it to.

One session, one task

I never let a session work two jobs. A session that's building a paywall doesn't also touch the landing page. Focus degrades in AI teams the same way it does in human ones.

This is what made the busiest week of my year possible. In late October I shipped a Naturalis update, an AteIQ update and Cascade 1.0 inside the same few days, each run by its own sessions with its own context. I was the only person involved, but at no point was anything sharing a brain with anything else.

Pick the model for the job

Tight, well specced build work goes to a smaller, faster model. Judgment heavy work, architecture, anything with tradeoffs goes to the bigger one. You wouldn't send a junior to negotiate a contract. Same thing.

Write briefs like you're paying for them

The quality of what comes back tracks the quality of what you send. Exact file paths. The decisions that are already made. What done looks like. Vague briefs produce confident nonsense.

Every brief also names which model runs it. That's a cost and quality decision I'd rather make once, up front, than leave to a default.

Teach it once, use it everywhere

When a pattern works, it becomes a skill: a written procedure the team can follow in any project. My apps share an onboarding pattern that exists as one of these, so a new app gets a proven flow instead of a rebuilt one. Each repo carries its own instructions file with the project's rules, the things I never want done, and the lessons that cost me something to learn. The team's memory is written down, which means it survives any individual session.

Verify everything

This is the big one. An AI once told me, with total confidence, which font my own app used. It was wrong. Now every claim needs a receipt: a file and line number, a screenshot, a number from the actual analytics. Trust the work, check the facts.

The rule cuts both ways. When the analytics said real users were reaching the payment sheet in Naturalis and every single one was backing out, that wasn't a fun read, but it told me precisely what to fix and saved me from redesigning things that weren't the problem. The same discipline that catches the AI's confident mistakes also catches mine.

Build rules that survive your mistakes

Cascade went to App Review with the word "free" in a screenshot. Rejected. It also shipped 1.0 with no analytics, so launch week was a guess. Both mistakes became permanent rules: every app ships with analytics and a review prompt from the first release, and everything going to review gets checked against the guidelines first. Process beats memory.

Keep the human parts human

The AI never decided what to build. It didn't invent Cascade, my son did, with a deck of cards at the kitchen table. It didn't catch the bug we found passing two iPads back and forth, where picking up a card quietly lit up your hand on the other player's screen. Playing the game found that. Taste, judgment and knowing when something feels wrong are still the job. Everything else is leverage.

What it can't do

Distribution. Or rather, it can draft, schedule and analyze, but the posts that actually perform for me are the human ones: my son counting down to his game's launch day, a bug we found passing two iPads back and forth at the kitchen table. A machine can't write those because it wasn't there. The audience can tell, faster than you'd think.

It also doesn't carry the consequences. When Cascade got rejected by App Review, that was my submission, my fix and my resubmission. The team is leverage, not liability cover. Everything that ships has my name on it, which is exactly why everything gets read before it ships.


The tools haven't replaced the work. They've changed what one person's work can add up to. A year ago, four shipped apps would have needed a team. Now it needs a director who takes the craft seriously.

My second rejected talk is already here as a post: adapting three shipped apps for iPhone Duo.

If you run a conference and any of this would be useful on a stage, my DMs are open.