#software
Blog
- The Tools We Use Shape How We Think
On the relationship between the tools we choose and the way we approach problems — and why it matters more than we think.
- The Debugging Mindset
Why the best debuggers aren't the ones who know the most — they're the ones who question the best.
- On Simplicity
Simple isn't easy. Thoughts on why the simplest solution is usually the hardest to find.
- In Praise of Friction
Not all friction is bad. Sometimes the resistance in your workflow is doing important work.
- The Case for Small Pull Requests
Why smaller PRs lead to better code, faster reviews, and fewer production incidents.
- Type Systems as Documentation
How a good type system replaces half your documentation and all of your runtime errors.
- Naming Things Well
The hardest problem in computer science, and some practical heuristics for getting it right.
- Reading Code Is a Skill
We teach people to write code but rarely to read it. That's a problem.
- Defaults Matter More Than You Think
Why the default configuration of your tools shapes your entire workflow — and your team's culture.
- All Abstractions Leak
Joel Spolsky was right. Every abstraction eventually forces you to understand the layer beneath it.
- Technical Debt Is a Bad Metaphor
The 'debt' framing makes engineers think about trade-offs wrong. Here's a better way to think about it.
- Start with a Monolith
Microservices are a scaling strategy, not a starting point. Most teams should start with a monolith.
- Writing Tests First Changed How I Design
TDD isn't about testing — it's about design. Writing tests first forces you to think about interfaces before implementations.
- Going Keyboard-Driven
How switching to a keyboard-driven workflow changed my relationship with my computer.
- Why Software Estimation Is Broken
We keep getting estimates wrong because we're estimating the wrong thing.
- Choose Boring Technology
Dan McKinley was right. Innovation tokens are limited. Spend them wisely.
- Building a Healthy Code Review Culture
Code review is a social process disguised as a technical one. The culture around it matters more than the tools.
- Refactoring Without Fear
Good tests make refactoring safe. Good architecture makes refactoring rare. You need both.
- Documentation-Driven Development
Write the docs before the code. If you can't explain it simply, you don't understand it well enough.
- API Design Is Interface Design
An API is a user interface for developers. The same design principles apply.
- A Simple Git Workflow That Scales
Trunk-based development with short-lived branches. No gitflow, no ceremony, just shipping.
- Escaping Dependency Hell
The more dependencies you have, the less you own your software. Here's how to be intentional about it.
- Observability Is Not Just Logging
Logs, metrics, and traces are the three pillars — but understanding how they connect is what gives you observability.
- Pair Programming Done Right
Pair programming isn't two people sharing a keyboard. It's a skill that requires deliberate practice.
- Error Handling Deserves More Thought
Happy paths are easy. The quality of your software is determined by how well you handle the unhappy ones.
- Writing Good Changelogs
A changelog is a letter to your future self and your users. Treat it with the care it deserves.
Notes
- TIL: git bisect is criminally underused
- Modern CLI tools written in Rust
- Monorepo tradeoffs in practice
- On writing small functions
- Structured logging saves debugging time
- Bun's test runner is surprisingly good
- The Temporal API is coming to replace Date
- SQLite is the most deployed database in the world
- JSDoc types as a TypeScript alternative
- Edge computing isn't always faster
- Signals are taking over frontend reactivity
- Testing Library's philosophy is right
- Deno 2 goes all-in on Node compatibility
- WebAssembly components are the future of plugins
Projects
- Static Search
A zero-dependency client-side search engine for static sites.
- Snippet Manager
A terminal-based code snippet manager with fuzzy search.
- JSON Explorer
A fast, searchable JSON viewer for large files with syntax highlighting.
- git-standup
CLI tool that shows what you worked on yesterday, across all repos.
- File Tree Generator
Generate ASCII file tree diagrams from directory structures.
- Dotfiles
My personal development environment configuration, managed with GNU Stow.
- DNS Lookup Tool
A simple web tool for querying DNS records with a clean interface.
- commit-msg
A git hook that enforces conventional commit message formatting.
- CLI Pomodoro Timer
A terminal-based Pomodoro timer with session tracking and stats.