What I'm doing now.

My first book is out now on Amazon: The Bottleneck Is Never the Stack, drawn from the essays here.

The back-and-forth these posts kept starting turned into something longer and more durable than a post, published under Brookfield Press with royalties going to Girls Who Code.

Shipped Barometer, an internet health monitor with a weather-station face.

It reads the public status of major cloud, DNS, and AI providers every five minutes, runs its own DNS probes, and normalizes the noise into one reading. Open source, serverless on AWS Lambda with S3 and CloudFront, and built around one rule: every failure resolves to unknown, never to a confident wrong answer. The launch post has the full story.

Speccing Rocinante, a keyboard-driven monitor for a fleet of agents.

A Go TUI built on the Charm stack, named after the ship. The bet is that watching agents work needs the same calm, glanceable instrumentation we built for watching servers, not another browser tab.

"What to Make of a Life" by Jim Collins, a reflective read from the author of Good to Great on the questions worth organizing a life around.

"All We Say: The Battle for American Identity" by Ben Rhodes, Obama's former speechwriter, telling the country's story through fifteen speeches from Franklin to Trump.

A timely look at how rhetoric draws a nation's competing self-portraits, and a fitting read for a quarter spent arguing that the frame is the bottleneck.

Go and the Charm TUI stack, by building Rocinante in it.

Coming to Go from years elsewhere, and learning how much a good terminal interface can carry when you stop reaching for a web frontend by reflex.

Serverless patterns for tiny tools that never sleep.

Barometer is the test bed. The interesting constraint is not capability but cost discipline at idle, which turns out to be the whole usage-billing argument in miniature.

Teaching Claude Code to remember across sessions.

I built a /reflect skill that gives an agent persistent memory between runs. The mechanics were the easy part. The real question underneath is what an agent should carry forward and what it should be made to forget.

What a design system needs when LLMs are first-class consumers: token naming that survives a code-gen pass, component APIs that don't leak Tailwind specifics, docs that double as agent prompts.

Inkwell is the current test bed.

Instrumenting verified outcomes, not tokens.

The ledger argument is easy to write and hard to operationalize. If value lives in outcomes that survive the stop, what does an enterprise actually measure, and where does that meter physically attach?

Who owns an agent's memory.

Persistent agent memory sounds like a feature until you ask who controls it, who can read it, and what happens when it is wrong. The /reflect work keeps pulling me toward that question.

Local versus metered inference as an architecture decision, not a line item.

Running a model on hardware I own versus renting one by the token is a portability and sovereignty call, and the kill-switch essay convinced me that is the part most teams underprice.

Native-app discipline as agent discipline.

Rebuilding a working web app as native software was the long way around on purpose. The rigor it demanded is the same rigor agents need to be trustworthy, and I am still mining that overlap.

The future of learning in an AI-native world.

When models can explain anything on demand, what does it actually mean to build expertise, and how should engineers, and kids, learn differently from here?