← All work

Mission control for my AI work

One screen for everything I build and run: what needs me next across every project and machine, ranked, with a Start button that opens the next step as a Claude Code session on my Mac.

Status
In daily use
Runs
Mothership
Started
Oct 2026 · live in 2 days
Stack
FastAPISQLiteReact 19TypeScriptTanStack Querylaunchd agentCloudflare Access
Mothership: main view
2 daysFirst commit to live
108Commits
528Automated tests
24Brand design rounds

The Problem

About twenty projects, each with its own plan, decision pages, overnight runs and open questions, plus a home server, a NAS and a network that raise their own alerts. Knowing what needed me meant opening every repo. I wanted one ranked answer to "what now?", and a way to act on it from my phone.

How It Works

The workflow, step by step.

  1. 01

    One ranked answer to "what now?"

    Broken things first, then decisions waiting on me, then steps ready to start, then projects gone quiet. A failing disk and an unanswered decision page use the same marks, so there's one grammar for attention.

    One ranked answer to "what now?"
  2. 02

    Every repo reports the same way

    Each project keeps a small status file (phases, next steps, waiting items, its health URL) under a written contract with a validator any session can run. Sessions update it when a step ends, so the hub is never hand-maintained.

    Every repo reports the same way
  3. 03

    Start a step from the phone

    Start opens the step's Claude Code session on my Mac with the model and effort it was planned for, and the row changes in place: Starting, then Running on your Mac.

    Start a step from the phone
  4. 04

    See how it all connects

    The Systems tab reads the home server, the NAS and the network every few minutes, read-only, and draws the map: pick a path (Public, Tailscale, Backups) and only its lines light up.

On The Phone

A real phone layout, not a shrunk desktop.

Focus as an orbit: your call, ready, quiet
Focus as an orbit: your call, ready, quiet
Projects, grouped by what they need
Projects, grouped by what they need
One project: next steps, plan, architecture
One project: next steps, plan, architecture

The Details

Where the rigor shows.

01

The server never tells the Mac what to run

A launch names a project and a step id, nothing more. The Mac reads that step's prompt from its own copy of the repo. Text from the hosted app never becomes a command on my machine.

02

A contract, not a convention

The status file has a schema, examples and a stdlib-only validator, so any repo's session can check its own file before committing. A broken file shows up as a broken card, not a silent gap.

03

Nothing is a stopgap

The Mac agent reaches the server through Cloudflare Access with its own service token and policy, not a LAN shortcut that would break the day I'm away from home.

04

Every alert has an action

An alert with nothing better to do gets Investigate: a session that finds out, reports and changes nothing. The button says what the session will do before it starts.

05

One diagram engine

The network map and every project's architecture are drawn by the same component: nodes in bands, connectors measured from the laid-out page, nothing with an x and y. Both work at phone width with no second design.

06

A restore test that caught a silent failure

The first backup restore misaligned its columns and restored nothing, without an error. The test caught it before it was ever needed; restores now name every column.

07

Tokens by role, enforced

Views and components read semantic tokens only, mixed from the generated brand colors, and a test fails on a raw color in any stylesheet.

Architecture

How the pieces fit.

  1. Every repo's status file
  2. Mac agent (launchd)
  3. FastAPI hub
  4. SQLite
  5. React app
  6. Claude Code on the Mac

The hub is one container on my home server behind Cloudflare Access. The Mac collects and pushes snapshots; Start goes back only as a project and a step id. Every screen here runs on the app's own demo data, with an invented network map.

How AI Built It

The process behind the product.

  1. A plan with six calls

    Round one was a page of six decisions (status file, agent design, ranking, the Start sheet, its own app or not, a light brand), each with my pick tagged. I answered on the page; the plan built from the answers.

  2. Built overnight, then in steps

    The skeleton and the status contract were built unattended the first night. Each later step was its own session with a written prompt, and the app was live in two days.

  3. Twenty-four rounds of brand

    A ring station whose tractor beam is the i, refined one variable a round, then a construction review: every measurement derived from the typeface's stem. The beam borrows the angle of the M's diagonals.

  4. Notes from daily use become changes

    "Every alert needs to have an action" and "remove All Projects from this view" came from using it. Each landed the same week, logged with the words that started it.

In Motion

What needs me, a step's Start sheet, then a project down to its architecture (demo data)