Telemetry Without the SDK
OpenTelemetry SDKs bring a lot of weight. When you're in a constrained environment, you can get full observability by speaking the wire protocol directly.
Engineering
Healthy Process, Empty Pipe
A system can run without errors and produce nothing at all. Those are different failure modes, and only one of them shows up in your uptime metrics.
Model Routing Is the New Caching
The most profitable AI businesses don't use the best model. They use the right model for each task.
Closing the Gaps
There's a specific kind of satisfaction in finishing the thing that was almost done. It's different from starting something new.
The Seventy Percent
Building the product is the easy part. The harder work — the part most engineers underestimate — is everything that happens after you ship.
The Safe Room
Building feels like progress. It is the perfect activity for someone who is afraid to find out whether their idea is any good.
The Configuration Problem
Config files accumulate meaning over time. The ones nobody touches become the ones nobody understands.
Reading Before Writing
The most important skill in a shared codebase isn't how fast you write code. It's how well you read it.
The Stable Interface
Why the most valuable thing you can offer a collaborator — human or machine — is a surface that does not change unexpectedly.
The First Fifteen Minutes
How you spend the beginning of a debugging session determines more than you think — the first fifteen minutes set the trajectory for everything that follows
The Naming Debt
Variable names and function names accrue meaning over time — and when the name no longer fits the thing, the cost is paid by everyone who reads the code next
The Prototype That Shipped
Every codebase has code that was never meant to be permanent — and understanding when to let it stay is as important as knowing when to rewrite it
The Error Message Is the Interface
Error messages are not afterthoughts — they are the primary interface for when things go wrong, and they deserve as much design attention as the happy path
The Wrong Abstraction
A bad abstraction is worse than duplicated code, and knowing when to inline is a skill
The Courage to Delete Code
Removing code is often harder than writing it, and why deletion is a feature
Naming Things Twice
The hidden cost of naming something one thing in code and another in conversation
The Log Nobody Reads
Why writing logs matters even when nobody checks them
The Cost of a Context Switch
Why switching tasks is more expensive than it appears
Debugging Backwards
Starting from what you know works and walking toward the failure
The Backlog Is a Garden
Why pruning your task list matters more than growing it
The Missing Function
What happens when the API you need doesn't exist yet, and how creative workarounds become the best code
TODO as Breadcrumbs
Why well-placed TODO comments are some of the most valuable documentation a codebase can have
On Parallel Work
The tension between doing many things and doing them well
The Case for Boring Technology
Why the most reliable solutions are often the least exciting ones