06Developer Tooling
Watching a dozen AI coding sessions without tabbing through windows
This is the personal project, and it is the one that best explains how I work: the problem was mine, the observation surface was whatever the tool already wrote to disk, and the constraint was that nothing could be instrumented, injected or sent anywhere.
Transcripts reach tens of megabytes, so any naive read-the-file-and-report approach is too slow to poll. That single performance constraint shaped the entire architecture.
Pure observation. Three read-only sources feed incremental ingesters, a derivation layer computes state, ETA and cost, and a change-hashed store pushes over SSE to a framework-free UI and an Electron shell that consumes its own loopback stream.
The transcript digester streams only the bytes appended since the last tick, from a stored byte offset, and persists digests to a local cache keyed on size and mtime. A cold scan of a large transcript is a one-time cost; every subsequent tick is nearly free.
Digests are written atomically — write then rename — so a crash mid-write cannot leave a corrupt cache behind.
State — working, waiting for input, blocked on a permission prompt, stalled, errored, idle, done — is resolved by a numbered rule sequence, with the order itself part of the spec. Where the implementation deviates from the contract, the module header says so and argues the case.
A separate scanner watches each session's sidecar agent directories, so a session whose main turn has ended but whose background agents are still running is correctly reported as busy rather than finished.
Cache reads, five-minute cache writes and one-hour cache writes carry different multipliers, so a blended rate is simply wrong. The price table resolves suffixed model ids by longest prefix, applies date-bounded intro pricing per message timestamp, attributes per-model within mixed-model transcripts, and excludes synthetic placeholder messages.
Timeouts fence every per-session scan, refresh is re-entrancy guarded, and every I/O path has a degraded handler. The server binds 127.0.0.1 only and is never routable, which is why it needs no auth — a decision documented in the module header rather than assumed.
The store broadcasts only when a clock-independent hash of the payload actually changes, so an idle machine produces no traffic and no repaints.
Re-reading is not an option at poll frequency. Streaming from a stored byte offset, skipping pathologically large single lines, and caching digests against size and mtime is what makes the whole dashboard viable — every other feature depends on that one decision.
When the main turn ends but background agents keep running, the obvious signal says done. Watching the sidecar agent directories — with bounded head and tail reads rather than full parses — is what makes the status honest.
The spec pins the exact serialized shape, the numbered rule order, the ETA algorithm, performance budgets, the full route table, and the design tokens down to hex values — enough that modules could be implemented independently against it. That is what let the work parallelise, and it is the same technique used on the larger platform projects.
The app makes no model calls and holds no API key. It is an observability layer over AI agent sessions, not an AI product — its AI-specific work is domain modelling of the pricing and the session lifecycle. It is also the clearest artifact of spec-driven, AI-assisted development: a written build contract, parallel implementation, then integration.
Native notifications fire on transitions into waiting-for-input, blocked, errored and done, with per-session debounce and a startup quiet window so pre-existing sessions are seeded rather than firing retroactively. The packaging script builds a real double-clickable macOS app — bundle, Info.plist, icns, ad-hoc signing — without any packaging dependency.
The spec is written as a binding build contract: exact serialized shapes, numbered rule order, performance budgets (a cold scan of ~116 MB under six seconds, never blocking the event loop more than ~50ms), the full HTTP route table, and design tokens. Nearly every module opens with a header explaining why — including the decisions that look wrong until explained: why the shell is CommonJS, why it reads its own loopback stream instead of importing the store, why the watches are non-recursive.
Objective size signals taken from the repository. No impact metrics are claimed that the source does not prove.
Local-only tool. Binds 127.0.0.1 and is never routable.