Mentoring on vnykmshr

The compiled person

Mon, 13 Apr 2026 00:00:00 +0000

I stopped being able to explain why I knew. That’s how I found out I’d been compiled. The patterns still fire, the fixes still land, but the source files are gone. No debug symbols, no way to step through my own reasoning.

A junior asked me how I’d known the bug was in the retry logic before I’d even read the function. I’d skimmed twenty lines. The answer was somewhere in my head. I tried to retrieve it and got nothing. Just the conclusion. The shape was right. I couldn’t tell you which pattern fired or where I’d learned it.

The invitation

Wed, 18 Mar 2026 00:00:00 +0000

First PR to an open source project, you’re proving you can read. That you studied the codebase, matched the style, understood why things are the way they are before suggesting they should be different. Most people skip this. Most PRs show it.

The second and third, you’re proving you’ll stay. Maintainers have seen hundreds of drive-by contributions. One PR, gone forever. The ones who come back are rare enough to notice.

Garbage context in, garbage code out

Sat, 07 Mar 2026 00:00:00 +0000

LLMs are exactly as good as what you feed them.

Experienced engineers feel like the gap between them and everyone else just got smaller. Someone with six months of prompting can ship something that looks like what took years to learn how to build. That’s the wrong read.

The output looks the same if you don’t look closely. The architecture doesn’t. The failure modes don’t. When traffic spikes and that generated code hits a path nobody thought about, the years show up.

The senior who stopped coding

Tue, 20 Jan 2026 00:00:00 +0000

The terminal closes slowly.

First it’s one meeting. Then a few more. Then you’re “senior” and your calendar is the job. Code reviews replace coding. Strategy replaces shipping. You advise. You guide. You no longer build. Seen this happen. Almost happened to me.

The problem is not the meetings. The problem is losing touch with the trade. Architecture diagrams don’t show you the queries that fan out under load. Sprint planning doesn’t show you the retry logic that fails silently. You can’t review what you can’t recognize.

The first five minutes

Mon, 30 Jan 2023 00:00:00 +0000

The prompt lands. A senior engineer, capable and prepared, starts drawing boxes. Load balancer, service tier, message broker, cache. Three minutes in, they are talking about shard counts.

The design is not wrong. It is not a design either. It is a collection of patterns assembled against a problem that has not been defined.

A system design prompt is deliberately loose. “Design a notification system for ten million users” has four different answers depending on what kind of notifications and which ones can be lost. “Design a URL shortener” has one shape at a thousand users and a different one at a billion. The looseness is the test. A person doing this work in production would not touch a whiteboard until the brief was tight enough to design against. The candidate who treats the interview as a different kind of activity from the work has missed what the interview is for.

The crossover

Wed, 23 Sep 2020 00:00:00 +0000

The second cloud migration lands on the roadmap in a staff meeting. On paper it looks like the first one. A target provider, a rough timeline, a named lead. I read the slide and expect the same work.

It is not the same work.

The first time

The first migration was easy to agree to. Our local datacenter had frequent outages and every one of them carried a physical tax – somebody drove over, pulled a cable, power-cycled a router. The DC had a support team, but the parts that mattered to us were ours to maintain. Cloud was the way forward and every one of us knew it. The decision did not take a meeting.

The compiler as first reviewer

Wed, 18 Jul 2018 00:00:00 +0000

When I joined, a few of us who had recently come in would skip the daily standups. Clock in, clock out, heads down. The rest of the team wasn’t sure what we were working on. This went on for a while. We were reading the existing codebase and quietly rewriting pieces in Go – proving it could handle production before anyone had to commit to it.

That changed when Go got formally introduced. The direction came from above – Go was the language for the new services. Now it wasn’t a side experiment, it was the stack. And the PRs were coming in faster than anyone could review them all.

Clean designs

Thu, 28 Oct 2010 00:00:00 +0000

Two years ago I walked into a classroom in our office. Not a meeting room. An actual classroom, whiteboard, rows of chairs. The company had hired an instructor to teach the new hires Java. Two hours a day, three days a week, for three months.

The training gave me syntax. Objects and classes. How inheritance works. What an interface is. The words for the things you do in code. Every week we wrote a small program and the instructor reviewed it.