Blog

On the relationship between the tools we choose and the way we approach problems — and why it matters more than we think.

Why I write about technical topics even when I don't fully understand them yet — especially then.

Why the best debuggers aren't the ones who know the most — they're the ones who question the best.

Simple isn't easy. Thoughts on why the simplest solution is usually the hardest to find.

Not all friction is bad. Sometimes the resistance in your workflow is doing important work.

Why sharing what you learn — even when you're wrong — is one of the best career decisions you can make.

Why smaller PRs lead to better code, faster reviews, and fewer production incidents.

How a good type system replaces half your documentation and all of your runtime errors.

Side projects aren't just for fun — they're where you develop taste and take risks you can't at work.

The hardest problem in computer science, and some practical heuristics for getting it right.

We teach people to write code but rarely to read it. That's a problem.

Why the default configuration of your tools shapes your entire workflow — and your team's culture.

Joel Spolsky was right. Every abstraction eventually forces you to understand the layer beneath it.

The 'debt' framing makes engineers think about trade-offs wrong. Here's a better way to think about it.

Microservices are a scaling strategy, not a starting point. Most teams should start with a monolith.

TDD isn't about testing — it's about design. Writing tests first forces you to think about interfaces before implementations.

How switching to a keyboard-driven workflow changed my relationship with my computer.

We keep getting estimates wrong because we're estimating the wrong thing.

Dan McKinley was right. Innovation tokens are limited. Spend them wisely.

Code review is a social process disguised as a technical one. The culture around it matters more than the tools.

Build for the baseline first. Layer on enhancements. Your users on flaky connections will thank you.

Good tests make refactoring safe. Good architecture makes refactoring rare. You need both.

Write the docs before the code. If you can't explain it simply, you don't understand it well enough.

An API is a user interface for developers. The same design principles apply.

Trunk-based development with short-lived branches. No gitflow, no ceremony, just shipping.

Modern CSS can do things that used to require JavaScript. It's time to update your mental model.

The more dependencies you have, the less you own your software. Here's how to be intentional about it.

Logs, metrics, and traces are the three pillars — but understanding how they connect is what gives you observability.

Pair programming isn't two people sharing a keyboard. It's a skill that requires deliberate practice.

Happy paths are easy. The quality of your software is determined by how well you handle the unhappy ones.

If you don't measure performance, you can't manage it. A budget gives your team a shared target.

A changelog is a letter to your future self and your users. Treat it with the care it deserves.