Every developer’s first real project isn’t a todo app. It’s their environment.

Think about it. Before you write a single line of production code at a new job, what do you actually do? You pick a font. You argue about tabs versus spaces. You install seventeen plugins. You spend an unreasonable amount of time on your terminal prompt. And somehow, nobody questions it. Because every developer knows, even if they won’t admit it, that the environment is the project that never ships and never stops evolving.

I believe this is the most honest thing about our profession. We can’t help it. We engineer our surroundings before we engineer anything else.

We build systems for a living, except where it matters

Here’s the irony. We spend our days engineering systems with clean interfaces, proper error handling, sensible abstractions. We obsess over code quality, test coverage, deployment pipelines. And then we go home to an environment that’s a random accumulation of whatever Stack Overflow answer we copied three years ago.

Your development environment deserves the same engineering rigor you put into production code. Not because it’s fun (it is). Because friction compounds. Every small annoyance you tolerate is a tax you pay hundreds of times a day. And unlike tech debt in a codebase, nobody’s going to file a ticket about it.

You’re the only user. You’re the only maintainer. You have no excuse.

What developer experience actually is

Developer Experience is not a product category. It’s not what your platform team sells you on a Friday demo. It’s not a VS Code extension with 47 stars on GitHub.

It’s simpler than that. And bigger.

Developer Experience is everything you arrange around yourself to reduce friction while you work. The hardware. The software. The scripts. The configs. The keybindings that live in muscle memory. The aliases that save you four keystrokes but somehow save you thirty seconds of mental context switching.

I see it as the compound interest of small, deliberate choices. A 30-line script that saves two minutes a day is twelve hours a year. But that’s not even the point. The point is that each deliberate choice trains you to notice the next friction point. The loop feeds itself.

Like training a team of Pokemon. Each one does one thing well, and the composition is what wins battles. You’re not looking for the legendary that solves everything. You’re building a balanced team with coverage for every situation.

Simple rules, emergent complexity

If you look at this page, there’s a Game of Life running in the background. It’s not decoration. It’s a thesis.

Conway’s Game of Life has four rules. Four. And from those four rules, you get gliders, oscillators, spaceships, Turing-complete computation. The complexity isn’t in the rules. It’s in what emerges when simple rules interact consistently over time.

Your environment works the same way. Small scripts. Simple conventions. Consistent patterns. Each one trivial in isolation. Together, they produce a workflow that looks complex from the outside but feels effortless from the inside. Emergent behavior from deliberate primitives.

Now add AI to the picture

Every few years, someone declares that developer tooling doesn’t matter anymore. IDEs were supposed to make configuration irrelevant. The cloud was supposed to make local environments pointless. And now AI is supposed to make everything obsolete because “just prompt it.”

They’re always wrong, and it’s always for the same reason: tools don’t eliminate environments. They inhabit them.

AI doesn’t replace your developer experience. AI reveals it. An AI assistant in a messy, undocumented, inconsistent environment is a Magikarp. Splashing around, no effect, wasting your time and your tokens. The same AI in a deliberate, composable, well-structured environment is a Gyarados. Same creature. Different context. Very different results.

The developers I see struggling with AI tools aren’t bad at prompting. They’re missing the substrate AI needs to be useful. AI is an amplifier, and amplifiers are only as good as what they amplify. Which is why I believe the current AI hype is actually making developer experience more important, not less.

What this blog is about

This blog is about that substrate. Developer craft. The small scripts, the tooling philosophy, the terminal workflows, the deliberate choices that compound over time.

Not because terminals are cool (they are). Not because AI is magic (it isn’t). But because your environment is the one project where you have full control, zero stakeholders, and infinite runway. The one place where you can be as opinionated, as meticulous, and as unreasonably invested as you want.

One cell at a time.