Last updated: November 2026
In 2025 I fully ditched Windows and the suite of tools cobbled together to be productive. My whole career has been spent analyzing data and complex systems. Like any skilled craftsman who has acquired the tools that work best for them, I set out to build a toolbox that makes my work both fun and productive. Maximizing for both of those led me to NixOS and Emacs.
Legibility (over mystery) - Understanding why everything with the system works is a crucial part of making the system brilliant. Configuration should be readable AND functional. Python's PEP 8 has a similar sense.
Declarative over imperative - declare what you want; let the system figure out how to build that. There's no hidden state and configuration is the single source of truth. If it's not in the configuration, it doesn't exist. No manual steps, no undocumented prerequisites, no tribal knowledge.
A useful byproduct becomes reproducibility. The same input (configuration) should produce the same output, every time.
A machine you cannot read is a machine you stop changing. Not by decision, just gradually, the way you stop touching a wobbly shelf. Each of these buys back the nerve to keep tinkering: legibility so you can see what you are about to change, declarativeness so you can state it rather than perform it, one source of truth so there is a single place to do it, and reproducibility so you can undo it. Being able to undo something is what turns a risky change into a cheap experiment.
It's really pleasant using tools that fit you exactly. I suspect in the age of AI we will see software trend to a hyper-customizable interface. Letting the pendulum sway back the other way, away from the current one-size-fits-all generic UIs (often crowded with places to click that will happily take your money for a service).
Most complexity that I work with occurs at the boundaries between things. As I started this work, a mental model began to solidify, and the decisions to be made and the problems to be solved seemed to fall into three domains.
Three layers, each an interface to the one below and a surface for the one above:
This is where I live and work.
Emacs is the primary surface here. Not because it is the best editor, but because it is the most composable thing available: a Lisp runtime that happens to edit text, extensible at every level. The cost of learning one general environment is paid once. The cost of learning ten special-purpose tools is paid ten times (and again each time one is replaced).
EWM (Emacs Wayland Manager) extends that composability to the window manager itself. Windows, workspaces, and the status bar are all Emacs, so keybindings and configuration are one language everywhere. Once the compositor is the editor, there is no second configuration language and no second place for state to hide.
AI agents live here too, in Emacs buffers rather than a terminal beside them: agent-shell drives Claude Code and Pi Agent over ACP.
When you, your agent, and your data are all in the exact same place, in Emacs, the context switching drops dramatically and the "time to done" for things I'm working on drops. I spend a lot of time thinking about how I interface with the world, and how to improve my quality of life through improving my interfaces. We have interfaces with many things, some simple areas where you invest in quality interfaces is worth doing. Some ideas - your pillow, mattress, pet food containers (instead of pulling out of the original bag), a good quality pen, a comfortable notebook, a comfortable keyboard, learn to type well - the list goes on. Moving on.
NixOS is the Operating System I utilize. Packages are expressions (declarative), not installations (imperative). The system is a generation: a single, atomic, reversible snapshot of the entire machine.
Attractive properties for your systems with this level:
There's an argument that NixOS moves the difficulty rather than removing it. Instead of debugging accumulated state, you debug a configuration language, and its error messages are not great. I think that the trade is still worth it: configuration errors are reproducible, they can be worked and corrected. Accumulated state is not. A machine that breaks the same way twice can be fixed once and you can move on. AI tools are incredible sidekicks to quickly iterate on any needed debugging as well.
Emanix is the distribution built on this layer. This is a distribution I have put together that focuses on these principles, shipping a minimal base system with Emacs and EWM on top of NixOS. The opinionated Emacs user would at this point load their configuration!
The operating system runs on a computer that is connected to the internet.
The reference machine is a Lenovo ThinkPad T14 Gen 5 AMD:
| Component | Spec |
|---|---|
| Processor | AMD Ryzen 7 PRO 8840U, 8 cores, Zen 4 |
| Memory | 16 GB DDR5 (two SODIMM slots, upgradable to 64 GB) |
| Storage | NVMe, user-replaceable |
| Display | 14" WUXGA 1920×1200, 16:10 |
| Graphics | Integrated AMD Radeon 780M |
| Ports | 2× USB4, 2× USB-A, HDMI 2.1, Ethernet |
| Weight | ~1.3 kg |
| Cost | $825 on eBay |
The properties that make it a good hardware layer:
The practical floor is far lower than this reference. There is no desktop environment to drag things down - the compositor is the editor process, so the entire graphical layer is one program. A used business laptop at a quarter of the price runs this stack comfortably. Older silicon, 8 GB of memory, and any SSD is a genuinely pleasant machine for this configuration.
The T14 really has just treated me well and has been a reliable choice for awhile now.
Two older essays reached parts of this before I did.
Gwern's Choosing Software (2008, revised 2012) is the criteria list I had been using without naming it: maintained, extensible, comprehensible, standard, efficient last. His case for comprehensibility is the case for EWM - with XMonad he could read the whole system, so extending and debugging stopped being mysterious and the code became the documentation. He also supplies the part my Emacs claim was missing. I said one environment is cheaper to learn than ten; the reason the bet is safe is that Emacs has history and institutional backing, so six months of learning amortizes over a denominator measured in decades.
His remedy for the cost of change appears in the same essay: take one, leave one - for every new tree planted, let one be uprooted, because redundancy increases inertia. Emanix moves that rule out of the operator's habits and into the distribution. It ships one shape, one answer per job - Emacs is the editor, the window manager, the terminal, and the file manager - and the non-goals list is the uprooting half written down, each entry a capability the distribution refuses rather than forgets. Gwern's version is imperative: you must remember to prune, every time you add something. Emanix's is declarative: a second tool does not exist unless it is typed into the flake. Redundancy becomes a deliberate, visible act in the single source of truth.
The price is standardness. Gwern would point out that Emacs and NixOS have no Bash-style network effects behind them, and he would be right. I am trading ubiquity for legibility, knowingly.
Stanislav Datskovskiy's Seven Laws of Sane Personal Computing (2010) states the same instinct as requirements rather than preferences. His second law, that information is never destroyed except by deliberate operator action, is what "being able to undo something turns a risky change into a cheap experiment" looks like when it is not negotiable. His fourth law, that compilation is a form of caching and the machine should behave like a hardware interpreter of a high-level language, is NixOS stated as a principle: derivations are pure functions, the store is the cache, the configuration is the program. His fifth law is the Emacs debugger. And his footnote rejecting the user/programmer split in favor of "operator" is the same objection that produced "Intelligence interface" - the vocabulary separating the person who uses the machine from the person who programs it is an artifact of barely-programmable systems, and it stops being true once the interface is legible.