My case: how a fleet of AI-built projects watches itself while I work on one thing

Here’s a case I almost didn’t notice I had, because it grew out of pain rather than a plan. I’m not a strong developer, and I run a lot of AI-built projects. For a while that combination produced a predictable misery: while I was deep in one project, others were quietly breaking — and I’d find out days later, by accident. So I built the thing I now consider the missing half of vibecoding: a fleet that watches itself.

Why this problem is baked into the AI era

AI collapsed the cost of building — that’s the whole vibecoding thesis. What it didn’t collapse is the cost of operating: forms stop sending, payment webhooks start erroring, crons die, certificates expire, third parties change their APIs — all after shipping, all invisible from the outside. And because building got cheap, a solo can now create far more live surface area than any human can manually watch. That’s vibecoding debt in its operational form: the portfolio rots wherever you aren’t looking — unless watching is automated too.

What the system actually does

No exotic tech — a small self-check layer that every project carries:

• Scheduled self-checks, with frequency by importance: quiet projects report daily; the ones where money or users flow report several times a day.
• Vitals, not vibes: is the site actually serving; are the critical paths (forms, checkout, email) alive; what appeared in the error logs since last check.
• Instant surfacing: an error in the logs shows up in the next report — not when I happen to look.
• One stream of state: regardless of which project I’m inside today, the whole fleet’s condition comes to me. Green means don’t think about it. Red means switch, fix, tune, return.

The deeper win is attention economics: a solo’s scarcest resource isn’t hours, it’s focused hours. Touring projects “just to check” burns focus on mostly-fine systems; self-reporting means my attention is spent only where something is actually wrong — which is the same leverage logic as the rest of the AI stack: machines do the watching, the human does the judging and fixing.

What it changed (honestly)

• Downtime stopped being silent. Problems surface in hours, not days-by-accident — which is the difference between a blip and a week of lost conversions on a project I wasn’t touching.
• Parallel portfolio became real. The projectologist model only works if unattended projects keep running; self-reporting is what makes “unattended” safe.
• Context-switching got purposeful. I switch on signal, not on anxiety.
• And the flip side stays true: a fleet that watches itself still needs its dead members properly decommissioned — monitoring a corpse just means scheduled bad news.

The log — as the system evolves

• 2026-08 (part 1, this post): the self-reporting layer runs across the active fleet — daily reports for quiet projects, multiple daily for the important ones, instant error surfacing from logs. Effect to date: silent multi-day outages eliminated as a category; repairs happen the day problems appear. Next: tightening the check tiers as projects graduate in importance.

Updates get appended here with dates — including the failures the system misses, if it misses them.

Part of the personal log. Sibling cases: the AI music label and the solo game studio — two of the projects this fleet watches.