Log

I spent six weeks building a system to keep an honest record of my life. The first honest thing it told me was that I’d stopped using it.

95 notifications, one action taken. Nothing it said was wrong. I just already knew all of it.

So I switched almost everything off. One interruption, and it has to keep score.

Score so far: zero.

The model isn’t the hard part anymore. Deciding what you let it do is.

Give it the messy jobs: reading whatever someone typed in, guessing a category, cleaning up a name. It’s good at those and it’s fine if it’s a little off.

Then stop. Anything that needs the same answer every time should come from plain code. Ask a model for a number twice and you get two numbers, and now you can’t trust either one.

The model is the cheap part now. Knowing where to stop using it is the work.

AI is making building cheaper, but it’s also making self-deception cheaper. You can ship an entire product in a weekend, feel insanely productive, and still learn absolutely nothing if nobody actually uses it.

It’s crystal clear now that the bottleneck was never the code. Because building was hard, it gave us a false sense of progress, hiding the real challenge of finding users and solving actual problems. Even as tools like Claude Code compress development to zero, that gap remains completely untouched.

The velocity of AI is predatory toward complexity. Spent 3 months building a custom orchestration layer for a project, only for it to become irrelevant after a single Claude update. Half my code is now just a well-crafted system prompt.

I underestimated how much better systems feel when logging is clean and intentional.

Spent 3 hours debugging something that turned out to be a timezone mismatch.

Back from the mountains again. There’s something about altitude that makes you think slower and clearer. Systems feel simpler when you’ve been disconnected for a few days.

The gap between “it works on my machine” and “it works in production” is almost entirely about configuration and environment assumptions.

Retries are underrated. A well-tuned retry with exponential backoff and jitter has saved more production incidents than any fancy architecture I’ve built.

Switched a hot path from JSON to protobuf. 40% latency drop. Serialization costs are real.

Thinking about system boundaries again. The hardest part of microservices isn’t the infrastructure — it’s deciding where one service ends and another begins. Get the boundaries wrong and you’re just building a distributed monolith.

Read a paper on CRDTs today. Conflict resolution is one of those problems that sounds simple until you actually sit with it.

Kafka is simple until it isn’t.

Every service that starts as “just a small wrapper” eventually becomes the hardest thing to replace.

Sleep over premature optimization. The number of production bugs I’ve traced back to decisions made while tired is non-trivial.

This year: fewer features, better systems.

The best debugging tool is still a good log line and the patience to read it.

Boring infrastructure is beautiful. The best systems I’ve worked on aren’t clever — they’re predictable, well-documented, and easy to reason about at 2 AM.

Back from a trek. Mountains have a way of resetting your sense of scale — both for systems and for life. Problems that felt urgent last week suddenly don’t.

Almost a year into my first engineering role. Shipped multiple projects, moved cities, and started to understand the difference between writing code and building systems. The learning curve hasn’t flattened yet — which is a good sign.

Consistency matters, but resilience matters more. Bad things will happen to systems and to people — the differentiator is recovery time. How fast you bounce back is the only metric that compounds.

Everything is going to be fine in the end. If it’s not fine, it’s not the end. — Oscar Wilde

The transition from student to professional is underrated in how disorienting it is. You go from a world where you set the rules to one where you’re operating within constraints you didn’t design. Takes a while to find your footing.

Finished college. Apart from a degree and an alumni card, what I actually take with me are the late-night debugging sessions, a few failed side projects, and friendships that will outlast any codebase I’ve written.