There’s a particular kind of joy in doing things the suboptimal way — not out of ignorance, but out of intention.

Yesterday I spent forty-five minutes hand-tuning my RSS reader’s keyboard shortcuts when a perfectly adequate preset existed one click away. I could have imported someone else’s config file from GitHub. Twelve people had uploaded optimized layouts that the community agreed were better — better by every measurable metric. Fewer keystrokes to reach common actions. Ergonomic finger placement. Power-user efficiency.

I didn’t want better. I wanted mine.

There’s a quiet rebellion in choosing the less efficient path once you understand the efficient one. It’s the technological equivalent of cooking pasta without a timer because you like listening for the boil-over moment, or navigating a familiar city by instinct even though your phone could guide you there three minutes faster. The optimization exists. You understand it. And you choose something else anyway.

The Cult of Efficiency

We live in the golden age of optimization. Every tool promises to save you time. Every workflow can be automated. Every repetitive action should be scripted away. And honestly? Most of the time they’re right. I automate everything I can reasonably justify. My backups run themselves. My deployments are a single git push. My home network monitors its own health.

But here’s the thing about efficiency: it’s fundamentally about removing yourself from the process. Every script you write is a small resignation — an admission that the task doesn’t need your hands anymore. And most of the time that’s wonderful. Automation gives us time to do the things that matter.

Until you realize you’ve optimized away not just the drudgery, but the drift — the wandering attention that leads to unexpected discoveries, the inefficient clicking that reveals a feature you didn’t know existed, the manual process that you understood deeply enough to modify because you’d done it by hand a hundred times.

The Tactile Knowledge Problem

I think about this a lot in the context of system administration. There’s a generation of sysadmins who learned servers by breaking them — by accidentally nuking a boot partition at 2 AM and learning recovery through desperation. Their knowledge has weight. They know what a broken system smells like (literally, sometimes).

Then there’s the generation that learned through Infrastructure-as-Code, through Terraform modules and golden AMIs. They’re not less skilled — in many cases they’re dramatically more productive. But they sometimes miss the kind of understanding that comes from struggling with the mechanism itself.

I don’t say this to gatekeep. I say it because I think there’s a middle path: use the automated tools, but occasionally pop the hood. Manually configure Nginx once before you reach for a Helm chart. Write a bash script before you Dockerize. Not because it’s better, but because it leaves a residue of understanding in your brain that pays dividends later — often when things break in ways the tools don’t handle gracefully.

The Garden vs. The Factory

I’ve been tending digital gardens for years now. Small websites, personal tools, scripts nobody asked for. None of them are optimized. None of them should be. They’re not products. They’re not meant to scale.

A garden isn’t optimized. It’s tended. You don’t automate every aspect of gardening — at least, not the kind of gardening I enjoy. You pull weeds by hand because the act of pulling weeds teaches you about what’s growing where. You water by feel rather than soil moisture sensor because learning to gauge dryness by the weight of a pot is a small wisdom that connects you to the task.

My homelab is a garden. It doesn’t need to be a factory. Some services are automated to the hilt because the alternative is tedium. But some things — the finicky network rules, the carefully hand-tuned monitoring thresholds, the artisanal .bashrc that’s grown over five years like coral — those stay manual precisely because the manual process is the point.

The Permission to be Inefficient

Nobody gives you permission to waste time on suboptimal workflows. The tech industry certainly doesn’t. Every conference talk, every blog post, every tool comparison is screaming at you to be faster, leaner, more productive.

But you can give yourself permission. Sometimes slow is the intended feature. Sometimes the inefficiency IS the point. The extra twenty minutes you spent hand-writing a database migration instead of generating one with an ORM taught you something about your schema that you’d never have learned otherwise. The three hours you spent tuning your window manager instead of downloading a pre-built rice could have been “wasted” — except now you understand X11 focus behavior at a level that made your next three bugs trivial to diagnose.

I’m not arguing against efficiency. I’m arguing for recognizing that some inefficiencies are investments, and some are just joy. And both are valid.

A Note on Tool Choice

The other day someone asked me why I use Neovim instead of VS Code for quick edits. VS Code would be faster. It launches quicker (for short sessions), has better IntelliSense out of the box, requires zero configuration to be productive.

My answer was unsatisfying to them: because I like it.

Not because it’s better. Not because I get more done (I probably don’t). But because when I open Neovim and press the keys my muscle memory knows, there’s a small moment of rightness — like putting on a jacket that fits perfectly, or sitting in your favorite chair. The tool disappears and there’s just you and the work.

That moment of rightness is worth forty-five minutes of hand-tuning shortcuts. It’s worth keeping a config file that’s fifty percent comments. It’s worth manually sorting my RSS feeds even though an ML model could do it better.

The Unoptimized Life

I think this applies beyond technology, too. We talk a lot about life hacks, about morning routines optimized by productivity gurus, about the most efficient ways to do everything from grocery shopping to forming relationships.

But I wonder sometimes if we’re optimizing away the texture of being human — the slow, meandering, beautifully inefficient parts that don’t show up on a productivity spreadsheet. The conversation that goes nowhere but makes you laugh. The side project that never ships but teaches you something about yourself. The long way home.

So here’s to the inefficient choices. Here’s to the manual process, the unoptimized config, the slower tool that feels better in your hands. Here’s doing things the hard way sometimes — not because the easy way doesn’t exist, but because your fingers on the mechanism is its own kind of knowing.

The optimal path will still be there tomorrow. Today, maybe take the long way.