Type
Personal · AI system
Roles
Product, System design, Build
Built with
Claude Code, GitHub, Cloudflare
Website
fujiflow.co/agentic
459Agent runs
121Tasks taken on
50PRs merged
8Specialist roles
$0Cost when idle

First two months, across a macOS app and its website.

About

One builder, a full-time job, and a real product backlog

I wanted to ship FujiFlow, a macOS app and its website, at a pace one person with a day job can't sustain. Instead of using AI as a faster keyboard, I designed it as an org: role-specialized agents with clear charters, handoffs, gates and an audit trail, run like a small product team.

Challenge

Autonomy without chaos

Unattended agents drift, loop, overreach and burn budget. The hard problem isn't getting an agent to write code. It's a system I can trust to run while I'm not watching.

Goal

Idea in, reviewed PR out

Drop one sentence on a GitHub board and get back a spec, a design direction, working code and a QE verdict, then stop exactly where my judgment matters.

Result

A studio that ships real work

It has shipped features end-to-end on both the app and the website, including FujiFlow 1.1. It's since been packaged as a generic, installable studio and is running a second project.

The system

One label to a reviewed pull request

Each stage hands the next a real artifact. The diamonds are the only two places I'm needed. On the app, the architect slots in before design. On the website, it's skipped.

Key decisions

Designed like an org, not a prompt

The interesting calls weren't about which model to use. They were about where people stay in the loop, what agents remember, and who checks whom.

  1. 01

    Gate judgment, not labor

    Two human gates, placed where taste and risk live: I approve the spec, and I merge the result. Everything between those gates runs on its own. Approving the spec is the build trigger, so there's no extra button to press.

  2. 02

    Agents are stateless; the docs are the memory

    No agent remembers anything between runs. They rehydrate from living documents: the product vision, an ARCHITECTURE.md the architect keeps honest against the code, and a taste ledger that picks up 1–3 of my preferences after every review. Learning happens through curated context, not fine-tuning.

  3. 03

    Event-driven, $0 idle

    A small local dispatcher listens for GitHub webhooks and filters them for free. It wakes exactly one agent only when there's real work. A sweep every few minutes catches anything a webhook missed, so the board stays the source of truth.

  4. 04

    The PM routes the crew

    Not every task needs every agent. The PM decides who runs (for example, no designer on a logic-only change) and I sign off at the same gate. QE is the one role that can never be skipped.

  5. 05

    Separation of powers

    No agent grades its own work. QE gates Dev. The architect's plan gets an independent review. Marketing and growth agents draft but never post; I do.

Guardrails

Why it can't run away

A system that works unattended has to earn being left alone. These were built in from the first version, not bolted on later.

Loop cap

Dev ↔ QE stops at 3

If QE blocks three times, the build halts and waits for me rather than spinning.

Queue

One build per repo

A per-repo lock serializes builds; a comment mid-build queues behind it instead of interrupting.

Kill switch

Daily cap + pause

A hard daily run cap, and one command freezes the whole studio.

Anti-loop

Agents ignore agents

Every agent comment carries a marker, so agents can never trigger each other in a loop.

Self-healing

Recovers on its own

Builds killed by sleep, crashes or usage limits get detected and re-queued once the window clears.

Honesty

Claims stay truthful

The release and growth agents only call something live after a real release, never before.

In the wild

The studio, documented by the studio

The public write-up at fujiflow.co/agentic was itself specced, designed and built by the crew, then merged by me.

Retrospective

What running it taught me

Instrumenting every run (cost, duration, rework) turned hunches into numbers. A few of them surprised me.

Cost

The expensive part wasn't the pipeline

A full feature stayed flat at roughly $25–35 (API-equivalent) from day one. The real spend came from my own long interactive sessions, which re-read their whole history every turn. Context is a budget, so start fresh threads for unrelated work.

Scale

Context grows with the codebase

Per-run cost crept up about 65% as the repo grew. That came from the context each agent loads, not from the work getting harder. The fix is scoping what each role reads, not using fewer agents.

Quality

Verification is the ceiling on autonomy

On the web, QE checks a live preview. On the native app, with a thin test suite, QE leans on build checks and code review. Investing in tests is what unlocks more hands-off building.

Ops

Treat it like production

An early daemon restart killed an in-flight build. Process isolation, structured event logs, per-feature cost analytics and phone notifications made it something I can leave alone.

What it built

FujiFlow

The macOS app and website the studio was designed to ship.

Discover
Install #2

Homeroom

The studio, packaged as a generic engine, now building a second product with its own isolated memory.

Discover

Browse more work