Introduction

I've been thinking lately about the relationship between the tools we use and the taste we develop. It's easy to treat tools as neutral — just means to an end. But they're not. The editor you use, the language you reach for, the framework you know inside-out — all of them quietly pull your taste in a direction.

Tools shape taste

Give someone a hammer and everything looks like a nail. That's the cliché, but the deeper version is that after enough time with the hammer, you start preferring problems that look like nails. Your sense of what's elegant, what's over-engineered, what's "the right way" — all of it gets calibrated against the tool.

I noticed this in myself with TypeScript. After a few years, I stopped seeing types as annotations bolted onto JavaScript and started seeing them as the shape of the problem itself. When I drop back into a dynamically-typed language, I feel the loss more than I feel the freedom.

The feedback loop

The loop looks something like:

1. You pick a tool because it fits the current problem.
2. You get fluent with it.
3. Fluency makes you faster with problems that suit the tool.
4. You unconsciously reach for those problems more often.
5. Your taste adjusts to match the tool's grain.

This isn't bad — specialization is how anyone gets good at anything. But it's worth noticing that step 5 is happening.

Taste shapes tools

The reverse is also true, and I think this is where the more interesting stuff happens. Once your taste is developed enough, you start rejecting tools that don't match it. Not for objective reasons — for aesthetic ones.

I know engineers who won't touch a codebase that uses a particular ORM, not because the ORM is broken, but because working with it makes them feel physically tired. That's a taste judgment expressing itself as a tool preference.

The really good engineers I know all seem to have strong, specific, sometimes irrational tool preferences. I don't think that's an accident.

What I actually do

For what it's worth, here's my current setup and the taste it's dragged me toward:

• Editor: Neovim. I use it because I got fluent in it early and switching costs are real. It has made me value keystroke efficiency more than I probably should.
• Language for scripts: TypeScript for anything longer than 20 lines, Bash for anything shorter. Python only when a library forces my hand.
• Framework: Next.js. Not because I love it — because the surface area is small enough to hold in my head and the escape hatches are cheap.

None of these are recommendations. They're just the shape of my current taste.

Closing

The tools-taste loop isn't something to fight. It's just something to be aware of. Every so often it's worth picking up a tool that doesn't fit your current taste — not to switch, but to feel where the friction is. That friction is usually pointing at something your current setup is quietly ignoring.