Skip to content

Topic

Engineering

Architecture, trade-offs and the decisions behind software that lasts.

Rust

Cargo's defaults ate 483 GB: a Rust build postmortem

A postmortem of build storage and test time across seven Rust workspaces: a 483 GB target folder that stalled a 32-core desktop on disk I/O, a release that ran another checkout's tests, a /tmp full of test leftovers, and the changes that fixed each one, with the numbers.

Read

Linux

Recording a window you can't see

"Record this window" sounds like the easiest feature in a screen recorder. On Wayland it took my own capture pipeline, a recorder I couldn't hide from, an audio server with a long memory, and a parent-death signal the kernel quietly drops.

Read

Linux

The compositor is still drawing it

Building easyshot taught me that the hard part of a Wayland screenshot tool isn't the capture protocol. It's the state you can't see, like a bar that's closed but still fading, a cursor painted into every frame, or a service started just by asking it a question.

Read

Rust

GPUI, after three apps

I've now shipped three native apps on GPUI, the UI framework behind the Zed editor: a system monitor, a terminal multiplexer and a screenshot tool. Each one pushed it somewhere different. This is what I know now about pinning it, patching it, budgeting it, and where it still runs out.

Read

Rust

What the terminal engine didn't promise

Insensical is built on libghostty-vt, Ghostty's terminal engine as a library. It gave me a superb parser. It didn't promise that every screen could be saved, that every saved screen could be read, or that it would answer questions in the right order. Here is what I built around it.

Read

Engineering

Seventeen years on both sides of the line

Most organisations separate the people who build software from the people who run it. I have spent my career doing both. Here is what that taught me about designing systems that survive contact with production.

Read

Security

Letting AI agents near production, carefully

AI agents are becoming colleagues with keyboards. After years of managing who can do what on servers, I've applied the same principles to them — least privilege, explicit actors, approvals and honest boundaries — across four tools I build.

Read

Operations

Release scripts that refuse to half-ship

The worst release is the one that stops halfway — a tag pushed, a package published, the documentation still describing last week. Every project I ship uses the same pattern to make that impossible: check everything, ask once, then do it all.

Read

Engineering

Rewrite history only when you can prove it

Nibble had thirty-six database migrations after its first week. Folding them into one per table was easy to type and hard to get right. The order of foreign keys was the whole job - and a schema diff was the only proof I trusted.

Read

Engineering

Designing software that strangers can upgrade

Anything a released version reads at runtime is a contract with the future. What Nibble taught me about upgrades — a release that can't know its own future address, why merging git history was the wrong model, and checksums that refuse to destroy your edits.

Read

Product

Why this site runs on a CMS I built

Every developer eventually writes a content management system. I did it on purpose, after years of installing, patching and rescuing other people's. These are the decisions that made Nibble — and the one I got wrong first.

Read

Engineering

Your own website is the best test suite

One evening of clicking around my own documentation produced seven patch releases of Nibble. Fixtures with three files never find what real content finds — and some bugs only show up when you actually run the thing.

Read