The studio behind the work
How I run a small AI product studio.
Every product here began as a single AI conversation. By the fifth, I was the only thing connecting them. This is how I turned that into a studio: specialist agents with defined lanes, a coordinator above them, and me as product owner.
One chat per product
It started simply: describe a problem from my own life in a chat and have a working page that evening. That worked well enough to scale, and scaling is where it broke. Each chat lost what the others knew. I was restating rules, carrying decisions between windows, and finding two chats solving the same problem two different ways. The constraint wasn't the AI. It was me, as the only shared memory.
Specialists with lanes
The first fix came from how strong product teams work: give each role one clear job. I codified the agents I kept recreating by hand, made them product-agnostic, and moved them into one shared library that every repo syncs from.
- Staff PM: starts from the bet, writes testable criteria, cuts scope, and runs go/no-go gates.
- QA (tests first): turns each criterion or bug into a failing test before anyone writes a fix.
- Engineer: makes that test pass in one small, reversible PR, and never merges or deploys on its own.
- UX reviewer: reviews every screen and word as the least tech-savvy person who will use it, on a real phone width.
- Privacy and security: holds each product to its own promise, like "logs never leave the laptop" or "photos never leave the phone".
- Positioning: keeps a register of what's true today, so no page or post claims more than the product does.
None is tied to a product. Each reads the repo it's working in first: its hard rules, its story and its current state. The same staff PM agent works on a kids' bedtime app and an energy CLI, and an improvement to one agent lands everywhere. On the family photo app, this review loop caught a co-parent data leak before any real user saw it.
A coordinator, not another builder
The more important decision was that one project should build nothing. Each product has its own project that owns its code. Above them, a coordinator, the product studio, holds the view across all of them: what moved, what stalled, what needs my decision, and where the portfolio stands.
It mirrors what happens when a team outgrows one person: the job shifts from doing the work to designing the system that keeps it on track.
The operating system around it
- One handoff file per repo. Every repo keeps a HANDOFF.md: what's done, what's in progress, the exact next step, and what's blocked. Every session reads it first, and a check fails any pull request that makes progress without updating it.
- One status list across the studio. A single page lists what's done and what's waiting on me. Anything done is never raised again, and anything waiting is never asked twice.
- The repo decides who owns the work. A change to a product's repo belongs to that product's project. Anything else goes to the studio. A project that needs a change it doesn't own writes a short intake, and the owner does the work. Routing never needs my judgment.
- Overnight shifts. Each product runs an unattended build at 2:15am, timed just after my usage limit resets. One night took ccwatts from a log parser to a working dashboard and playground in seven small PRs.
- A morning digest. At 6:30 I read one short summary: what shipped overnight, what's blocked, and the one thing that needs me today.
- A story log. Every notable call goes into a running log as it happens, which is the source for this page.
My job became the product owner
I don't review the code line by line. I review the pull request descriptions: what changed and why, how it was tested, and which decision is mine. The agents write for that reader, so a clear description is part of the deliverable.
Nothing reaches a live site or a user without me. Agents open draft pull requests and stop. My evenings shifted from writing prompts to making decisions: approve, cut, or return it with one sentence of direction. In one recruiter-ready sprint, three review rounds found 21 issues in ccwatts, and every one was fixed test-first across eight small draft PRs overnight.
What I took from it
- Write the rule down once. A hard rule in the repo is followed by every session. One stated only in chat is gone by the next.
- One source of truth per thing. When status lived in three places, it drifted in three directions.
- Make every ask one step. My time is the scarcest resource in the studio, so every request is a link, a paste box or a one-word choice.
- Credibility comes from candor. Agents say "untested" when they couldn't check something, and sample data says so everywhere.