From the marginalia

What I Use: Constraints and Good Iron

Most What I Use posts are vanity galleries: aluminium rectangles and SaaS subscriptions arranged for the reader’s envy rather than their use. The format invites it, and I’ll try not to fall in. But there is a real value in seeing how someone else has shaped their friction. Tools are leverage; an environment that fights you bleeds time and focus you cannot get back.

I came to this work from kitchens and mining camps. In a kitchen, a knife roll is your livelihood. In a camp, bad gear can get you killed, or at the very least fired. Software is gentler than either, but the principle holds: the gear should disappear so the work can show through.

Here, then, is what I read, write, and build with. Local-first where it matters. No cloud accounts, no marketing copy, and as little ceremony as I can manage.

I. The Iron & The OS

A ThinkPad T14s AMD Gen 6, 32 GB of RAM. A workhorse, not a lifestyle accessory. The AMD chassis runs warm under load and cool under prose, which is the right way around. I keep Windows 11 Pro on a dual-boot partition for the handful of programs that demand it, but the work happens in Linux.

Fedora 44 Workstation, GNOME on Wayland. Fedora’s pace suits me: aggressive enough to stay current, conservative enough to leave my afternoons mine. Arch wants a roommate; Ubuntu wants a tenant. Fedora is content to be a desk.

A phone lives in the other pocket, an iPhone 16 Pro, but it is a triage device, not a workstation. We’ll come back to it.

II. Aesthetics as Ergonomics

Twelve-hour stretches in front of a screen are easier to survive when the screen is willing to compromise. Pretty is not the point; humane is.

The terminal runs Gruber Dark. Everything else (Neovim, Emacs, the standalone GUI tools I write) runs Kanagawa Dragon. It is the rare dark theme that earns its contrast: no searing accents, no neon to apologise for at midnight. The Emacs port I use is my own, kanagawa-dragon-nvim-emacs, because the existing Emacs Kanagawa packages had the palette right but covered nothing like enough faces. It is a work in progress; the Java buffer at treesit-font-lock-level 4 is my acceptance test.

Code is set in TX-02 at semi-light, 18pt. Org-mode prose is set in Tiempos Text at 20pt. Both are premium licensed faces, and that is the trade I accept: pay once, look at it forever. TX-02 in particular draws zero and O with enough air between them that I never second-guess a literal in a hex dump. This site, incidentally, is set in Source Serif 4 and IBM Plex Mono: the same Source Serif that Atrium ships in for its body text. Full circle.

The mouse pointer is phinger-cursors. The default Adwaita pointer is fine; phinger is better. Larger hit-area, cleaner silhouette, a hand variant that actually looks like a hand. The kind of small replacement that vanishes inside a week and that you then cannot go back from.

III. The Two-Brain Architecture

Trying to make one piece of software hold the whole of a working life is how you get mediocrity in both halves. VS Code wants to be an operating system. I want an editor. I keep writing code separate from running my life, on purpose.

IV. The Terminal Ecosystem

The Suckless inheritance is honourable, and I patched my share of dwm and st in earlier lives. But I do not romanticise GNU coreutils when a generation of Rust and Go rewrites has quietly fixed most of their corners. The terminal is the place I spend the most consecutive minutes; it gets the most current tools.

Ghostty under zsh, with starship for the prompt and atuin for shell history I can actually search. Ghostty’s renderer is GPU-accelerated and stays smooth under font ligatures and 24-bit colour, which is more than I can say for some of its predecessors on this exact laptop.

The coreutils replacements have become muscle memory: eza for ls, bat for cat, rg for grep, fd for find. rg honours .gitignore by default, which is the entire reason; bat paints what it shows; eza reads file sizes with units instead of bytes. zoxide learns my directory habits so I stop typing the same eight characters every morning. lazygit is the rare TUI I prefer to the underlying command, and that is a high compliment. Underneath all of it: fzf, the connective tissue.

V. The Desktop & Application Stack

Homescreen

GNOME ships honest defaults; I bend a few of them. Pop Shell brings tiling for the windows that do not want to float, Vitals keeps the sensors on the panel, and Blur My Shell sands the seams. After that, GNOME stays out of the way, which is the only thing I have ever wanted from a desktop.

The application layer is where I am pickiest, because most of what passes for desktop software in 2026 is a web app wearing a coat. I try to keep the coats out.

For RSS, an Inoreader backend reads my feeds because its filter rules are still ahead of the field. The local client today is NewsFlash, at least until I switch fully to my own Viaduct, which already runs my OPML well enough that admitting NewsFlash is still here is starting to feel slightly sheepish.

VI. The Library

Calibre is my favourite program on any operating system. That is a small confession to drop into a What I Use post, because Calibre is also one of the homeliest pieces of software you will ever boot: a Qt5 application with the visual confidence of a 2009-era tax form and a ribbon that has not been redesigned since the iPad was new. None of that matters. Underneath the surface is a fully indexed SQLite library, a real search-expression grammar with a proper parser, and a virtual-library system that lets a careful user build their own taxonomy and never lose track of where a book lives. It is the closest thing the open-source world has to a digital-archivist’s framework, and almost nobody talks about it as one.

My library runs to four-thousand six-hundred-and-change books. Mostly EPUB, about fifteen-hundred PDFs, a long tail of DjVu where the scan is the only thing that exists, and an embarrassed handful of MOBI from before I knew better. Almost all of them are catalogued. The catalogue is the point.

The taxonomy is the part I am most pleased with. Every tag is a path. There are three roots, Fic, NonFic, Gaming, and every other tag is dot-separated underneath them. Fic.Fantasy.Grimdark. Fic.SciFi.SpaceOpera. NonFic.Tech.CS.Compilers. Gaming.TTRPG.WoD.Vampire. Three-hundred-and-sixty-eight tags in the tree, mostly three levels deep with about seventy at four. That structure is the seed of Hermitage’s recursive tag browser; that grammar is what CalibreQuarry’s parser was written to handle.

On top of the tag tree sit twenty virtual libraries, all of them named Wing: the Grimdark & Epic Wing, the Sci-Fi Wing, the CS Wing, the Historical Fiction Wing, the Programming Wing, The Tabletop, The Classics. Calibre virtual libraries are search expressions saved against the library, and they compose. An IT Wing says (tags:"NonFic.Tech") and not (vl:"CS Wing" or vl:"Programming Wing"), carving its scope out of what other wings already own. An Unsorted Wing is the not of every other wing, so any book that escapes the taxonomy surfaces in the first place I would look. The whole arrangement is checkable: every book either belongs to exactly one wing or sits politely in the backstop until I file it.

Two custom columns earn their keep. Audience keeps adjacent fiction sorted without bleeding genres. Status is an enumeration (unread, reading, finished, abandoned, reference) and it is the field that turned the library from a hoard into a reading practice; an unread → reading → finished gradient that I can sort, filter, and report against.

Series fidelity is the other discipline. Five-hundred-and-fifty-four series in the database, the largest being Discworld at forty-one books, then the full Aubrey-Maturin, the full Vorkosigan Saga, the full Expanse, all of Dresden, all of Wheel of Time. Where a series matters, the gaps are filled. CalibreQuarry’s --audit series-gap mode was originally written against this library to catch the books I had told myself I would come back to and never did.

Most digital-library tools assume you want a Netflix-style infinite scroll. Calibre assumes you want a card catalogue and the muscle memory of a librarian. The latter is the right assumption for a library you intend to live with.

VII. The Reader: Ink & Type

The library lives on the laptop; the actual reading happens on a Kindle Oasis (last generation). The Oasis was the only Kindle worth owning: aluminium back, an asymmetric grip with hardware page-turn buttons, an actual warm-light slider. The only Kindle that ever felt like an object instead of a tablet. Amazon discontinued it. The current Kindle line is split between a basic plastic slab and a Scribe-branded notepad, and neither is the reader the Oasis was. The Voyage is gone; the Oasis is gone; Amazon’s premium e-reader segment is effectively gone. The state of the high-end e-reader market in 2026 is the most frustrating it has been in the device’s twenty-year history.

That has me looking sideways. The candidate I keep returning to is the PocketBook Era. PocketBook is one of the few remaining independents in this category. The firmware sits on top of Linux without trying terribly hard to hide that. The screen is a current-generation Carta panel with the contrast you stopped getting on cheap Kindles. The device is not tethered to a retail account. After more than a decade inside Amazon’s reader ecosystem, that last point matters more than I want to admit.

Colour e-ink stays off the table. The Gallery and Kaleido panels currently render black-and-white text visibly softer than the best monochrome Carta, and reading is the application I am least willing to compromise on. The day a colour panel renders monochrome text the way a monochrome panel renders it today is the day I reconsider. Not before.

The reason an Oasis is still on my nightstand at all, frankly, is the font hack. Both side-loaded faces come from the MobileRead forums, which is the place on the open internet where people who care about how an e-reader renders type have been talking for fifteen years.

Both fonts archive cleanly in Nico Verbruggen’s ebook-fonts repository, which is what to grab if you do not want to dig through fifteen years of MobileRead thread history to find them. That the good fonts for an Amazon e-reader come from a forum and not from Amazon is the most honest summary I can give of the premium e-reader market in 2026.

VIII. The iPhone: Triage & Consumption

A phone is a triage device. If real work is happening on a six-inch glass rectangle, something has gone wrong upstream. So the homescreen is arranged for speed, not scrolling.

Page one anchors on a tall Fantastical widget. Natural-language event entry remains its killer feature, and Apple’s calendar still cannot read lunch with M next Tuesday at 1. The dock is the working core: a Learning folder (Blackboard, Reminders, PCalc, Soulver), Messages, Safari, and Claude. The desktop is where the heavy lifting happens, but a high-reasoning model in my pocket has quietly become one of the most useful things I carry.

Around it: Raindrop.io for bookmarks, Overcast for podcasts (Smart Speed and Voice Boost are doing real audio-engineering work, not posturing), foobar2000 for local audio because it has never failed me in twenty years, and Awful because the SomethingAwful forums require their own client and I refuse to engage otherwise.

The folders break out cleanly. An Important drawer (Tangerine, Wealthsimple, Passwords, 1Password, Outlook, AnyList, Authy, LocalSend, Cronometer). A Feeds drawer (Reddit, WhatsApp, Mail, Ice Cubes for Mastodon, HEY for the email I want and not the email I am given, and NetNewsWire because the iOS port is still the gold standard). A Social drawer (Discord, LinkedIn, Steam, Spotify, Snapchat, Phone, LibraryThing, GitHub).

Page two is utility. A large Todoist widget shows today’s shared tasks; underneath it, a smart-stack widget rotates between CARROT Weather, Mail, and Gmail. CARROT Weather is there because the default app gives a polite shrug where I want a radar.

IX. Custom Code: Building What I Need

Eventually you get tired of compromising. Native GTK4, SQLite in WAL mode, a single-writer worker, FTS5 indexes where search has to be fast: that is the loose architecture I keep coming back to, and it is the entire reason these exist instead of an Electron lookalike of each one.

Before the list, a structural note. Every project here ships the same scaffolding. A public README.md for the front door. A spec.md that defines the contract, the file I read before changing semantics. A roadmap.md with phase-by-phase checkboxes that get ticked when a release lands. A patchnotes.md with newest entries at the top. A LICENSE and a logo.svg from day one. A single VERSION source of truth that pyproject.toml or Cargo.toml mirrors and never gets out of sync with. And a per-project CLAUDE.md that documents the project’s contract for the assistant I work with (more on that in §X). The scaffolding is half the value: it means I can drop back into any of these after weeks away and pick up where the last release left off, without re-reading the code to remember what the contract was supposed to be.

X. The AI Layer: Augmented Intelligence

I treat large language models as cognitive compilers, not search engines. They are wonderful at structural review, mechanical refactoring, boilerplate, and rapid synthesis. They are bad at facts, and they will never be reliable at facts in the way the marketing implies. Use them where the cost of being wrong is cheap and the value of being structured is high. I will say plainly what the rest of this section will demonstrate: this is the most controversial corner of the workflow, and I have made peace with that.

The model is Claude Fable 5, the top of the line, as Opus was before it (this post originally said Opus 4.7; the tier is the part that doesn’t change). Not the smaller tiers, not the API for one-shots. Claude Max bundles it into the plan, so I leave it on and never look at the meter. I run it twelve to fourteen hours a day, every day, against the projects in §IX. The reasoning gap between the frontier model and the rest matters most at the design level. At the moments where I am sketching a schema or shaping a parser, the assistant either has the architecture in mind or it doesn’t, and a faster wrong suggestion is worse than a slower correct one. The frontier model has the architecture in mind. The rest of the family doesn’t, not in the same way, not yet.

The interface is Claude Code, in the terminal, by itself. No agentic harness, no IDE extension, no third-party orchestrator layered on top. There is a small cottage industry of AI-assistant wrappers and meta-tools at the moment, and most of it is an attempt to recoup ergonomic decisions the user could make for themselves. I made mine. Plan mode for any non-trivial change. Tight, specific prompts. No guessing when something is genuinely ambiguous; the model comes back with a question instead.

The actual workflow lives in the CLAUDE.md files. There is a global one at ~/.claude/CLAUDE.md that carries my voice, my languages, my hard rules. No Docker. No cloud-only services. Tests are not optional. Don’t rely on my fonts. There is a workspace one at ~/.gitrepos/CLAUDE.md that maps which directories are portfolio code, which are exploratory, which are for friends, and which are read-only by policy. And there is a per-project one in every repo with that project’s contract: the spec, the conventions, the things that must not break. The three load in order, most-specific wins, and the result is a layered context that does the same job a long-tenured human collaborator does on a small team. No prompt-engineering theatre. The same instructions I would give a person if a person were available.

The other half is the memory system. The assistant writes its own notes against my projects, what I corrected, what I confirmed, what I told it to ignore, and reads them back when relevant. The notes are mine to audit, edit, and prune. Most of the corrections that used to recur don’t anymore, which is the only end-state that matters.

Gemini Pro stays installed as a second opinion when I want to cross-check a structural decision against a different architecture. I would rather have it and not need it.

I expect this section to age the fastest of any in this post. That is a property of the field, not a bug in the write-up.

← Return to the codex