I build software, but I'm even more interested in the systems behind it.

Most days I'm thinking about boundaries, incentives, information flow, and the subtle ways software influence human behavior.

Code is simply how those ideas become real.

Professional overthinker. Occasionally, the overthinking compiles.

Current relationship status:

Committed to Git.

• Every module should have one owner and one reason to exist.
• The best abstractions remove decisions instead of adding flexibility.
• Architecture isn't about layering. It's about reducing the cost of change.
• Performance includes developer experience. Slow code wastes minutes. Bad architecture wastes months.
• If two components know too much about each other, they're probably in a relationship they shouldn't be in.

Software isn't just logic.

It's:

• Psychology
• Economics
• Communication
• Trust

A login screen changes behavior. A loading animation changes patience. A notification changes attention. An API changes how entire teams think.

I'm fascinated by those invisible effects.

Every technical decision eventually becomes a human decision.

I genuinely enjoy writing code.

But somewhere along the way I became more interested in why software works than merely how.

Now I can't look at an app without wondering:

• Why does this button exist?
• What assumption does this workflow make about the user?
• Which team owns this responsibility?
• Could this entire feature disappear if the system were designed differently?

It's difficult to turn that part of my brain off.

I don't really want to.

• I write TODOs as though Future Me is a completely different engineer. He isn't. He also ignores them.
• I care way too much about loading animations considering users see them for like 600ms.
• I enjoy deleting code almost as much as writing it.
• I've redesigned perfectly functional systems simply because they felt dishonest.
• Sometimes architecture diagrams appear before the code. Sometimes before breakfast.

I've been learning AI engineering from the ground up.

What fascinates me isn't just training or prompting models—it's treating intelligence as another architectural building block.

Databases store memory. APIs exchange information. Queues coordinate work. Models reason.

The systems I'm excited to build don't revolve around one all-knowing model.

They combine small, specialized components that observe, recommend, retrieve, predict, and assist—each responsible for doing one thing well.

The interesting engineering starts when all of them work together.

The challenge was never adding AI.

It's deciding where intelligence belongs—and where it doesn't.

Every bug teaches us something.

I care far more about solving the right problem than using the right framework.

These just happen to be the tools I've enjoyed building with recently.