Running 7 Products as One Developer: What I Delegate to AI

Running multiple products solo sounds like a scheduling problem. It isn't. Scheduling is just logistics — you can optimize it with better habits and a calendar. The real problem is cognitive load: every product has its own domain knowledge, its own user context, its own open questions. Context-switching between them is expensive in a way that hours on a calendar don't capture.

AI hasn't solved that problem, but it has dramatically reduced the cost of the parts that were burning the most time. Here's what I actually delegate, what I don't, and what I learned along the way.

What Kills Solo Productivity#

Before getting into the AI tools, it's worth naming the actual bottleneck. Seven products means seven sets of users, seven codebases (in my case one codebase, but seven distinct configurations), seven support inboxes, and seven sets of decisions that require context to make well.

The failure mode isn't running out of hours — it's running out of attention. You make worse decisions later in the day, especially on things that require holding a lot of context at once. The goal is to protect high-attention work and delegate everything else.

AI is good at most things that don't require judgment. Judgment is the scarce resource.

Writing First Drafts#

Every product needs content: landing page copy, email sequences, blog posts, support documentation, outreach messages. I used to batch this into dedicated writing sessions that would eat half a day.

Now the workflow is different. I write a short brief — who this is for, what it needs to accomplish, what tone fits — and use AI to produce a first draft. The draft is never final, but starting from something is dramatically faster than starting from nothing. I edit rather than write, which is a different and cheaper cognitive mode.

The key is writing a tight brief. Vague input produces vague output. "Write a landing page for my immigration app" produces generic marketing copy. "Write a hero section for an immigration visa tracking app targeting Korean nationals in Japan — direct tone, no hype, lead with the specific anxiety they have about missing deadlines" produces something editable.

The brief takes five minutes. The edit takes fifteen. The old process took two hours.

Outreach and Follow-Ups#

Cold outreach is mostly pattern matching at scale: find the right person, understand their context, explain what you can do for them. AI is good at all three parts individually, though the combination still needs human review.

For each product I run outreach for, I have a system that scrapes basic context about a prospect (what they do, what their site says, recent activity), then generates a draft message grounded in that context. I review and edit before sending — I don't send AI output verbatim — but I've cut the time to craft a personalized message from fifteen minutes to three.

The follow-up cadence is something I now handle almost entirely through templates AI helped write. The judgment call — when to follow up, when to drop a thread — is still mine. The actual writing isn't.

Debugging and Code Review#

This is the highest-leverage AI use for an individual developer. Being able to paste a function, describe the unexpected behavior, and get a plausible explanation in ten seconds — that used to be a rubber duck problem that could stretch into an hour.

I use AI for the first pass on any debugging session. Not because it always gets it right, but because it generates hypotheses quickly. Half the time the hypothesis is wrong and I learn something by figuring out why. The other half it's right and I've saved significant time.

For code review on my own PRs, AI catches the categories of issues I'm most likely to miss when I'm too close to the code: missing edge cases, inconsistent error handling, things that are technically correct but will confuse the next reader (who is usually me, three months later).

What I Don't Delegate#

Product decisions. What to build next, what to cut, how to price — these require knowing what users actually want, what the market looks like, and what I'm willing to maintain. AI can synthesize information, but it can't weigh the tradeoffs for my specific situation.

User conversations. When a user has a problem or a question, I respond personally. This is where trust is built. Automating it would save an hour a week and cost far more in product insight.

Anything architectural. Technical decisions that compound — database schema, authentication patterns, how state flows through the app — I make slowly and deliberately. Getting these wrong is expensive. AI suggestions here are a starting point, not a conclusion.

Judgment calls under uncertainty. Any decision where the right answer depends on information that isn't in my context and can't be retrieved, I make myself. AI is confidently wrong in ways that are hard to detect, and the cases where you most need to be careful are the ones where it sounds most certain.

The Actual Productivity Gain#

Across seven products, I'd estimate AI saves me eight to twelve hours a week — mostly in writing, research, and first-pass debugging. That's not magic; it's closer to having a fast junior collaborator who's good at tasks with clear inputs and outputs, bad at judgment, and never sleepy.

The ceiling on solo product development isn't hours. It's the number of things you can hold in your head well enough to make good decisions about. AI doesn't raise that ceiling — nothing does. What it does is reduce the number of hours that get consumed before you hit it.