Or: An ode to self-awareness, from one quality bottleneck to another.

You leave your kid at daycare every morning. A stranger with a certificate keeps your most precious thing alive while you work, and you're fine with it. You even pay them for it. Then you drive to the office and refuse to let another professional touch your service.

Your kid — the human one — you trust to professionals. Your kid — the FastAPI one — apparently only you can hold.

One of these is irrational. Hint: it's not the daycare.

I've written before that everyone is replaceable. Some of you read that and nodded. Some of you read that and quietly appended "except me." This one is for the second group. I know you well. I've been you.

The Quality Keeper

Nobody wakes up one morning and decides to become the bottleneck. It happens the way most bad things happen in software: gradually, with good intentions, and without a single alert firing.

You work on a project for too long. Years. You know where the bodies are buried because you buried half of them. You know why that retry logic looks insane — because the vendor's API lies on Tuesdays. You know which config flag is load-bearing and which one is decorative. You know the system.

And knowing the system does something to your brain. The service stops being a service. It becomes your kid. You raised it from a PoC. You fed it at 2 AM. You watched it take its first production traffic.

So when someone new wants to touch it, something in you tightens. Letting others in means one of two things, your brain whispers: either they'll prove you obsolete, or they'll lower the quality. Because you are the quality keeper. The last line of defense. The gate.

Here's the part nobody tells you, because nobody tells the gatekeeper anything anymore: you are not the quality keeper. You are the quality bottleneck. And the evolution bottleneck. Every PR waits for you. Every design goes through you. The codebase can't grow past your calendar, your taste, your availability. That's not guardianship. That's a lock on the door with one key, and you swallowed it.

The company sees a dedicated senior. The team sees a queue.

Home Alone

The illusion is stable, right up until reality runs one of its three favorite tests.

Test one: you leave the company. The classic. You hand in your notice and brace for the collapse. The collapse doesn't come. The systems keep running. Someone else picks up the pager. The company survives, painfully anticlimactically, and the job posting was probably drafted before your farewell cake was ordered. I've covered this movie before. It never gets a sequel because nothing happens.

Test two: you take a real vacation. Two weeks. Phone in a drawer. You come back tanned and slightly nervous, expecting smoke.

The house is fine.

Worse than fine — it's Home Alone. Incidents came, burglars at the door, and the house handled them with what was already inside it. Paint cans on strings. The runbooks you wrote. The tests you insisted on. The two engineers you trained and then never fully trusted. Kevin didn't need the family operationally. He needed them emotionally. Sit with that difference for a minute, because your ego can't process it: the service missed you the way a house misses its owner. Which is to say, not at all. The people maybe missed you. The uptime didn't.

Test three is the new one, the 2026 one, and it's the reason this article exists. The other two tests took a resignation or an annual leave to run. This one takes a sprint.

Kindergarten Cop

A new face shows up at your daycare. Wrong background. No pedagogy degree. No reverence for your methods. A mid-level engineer with an agent stack, a vague plan, and none of your twenty years.

By Friday, he's running the room.

He ships a big feature — in your codebase, your kid — in a fraction of your estimate. And here's the part that stings, the part you were quietly betting against: the quality doesn't meaningfully drop. The review you were sharpening your red pen for comes back... fine. Not beautiful. Fine. Working, tested enough, shipped.

"It's not a tumor." And it isn't. That bug you were sure his code introduced? Check the blame. It was there before he arrived. Under your exclusive guardianship.

Now, let's be honest, because this blog runs on honesty and not on hype. The vibe coders have real failure modes. They break test beds because they don't know the SDLC — they've never lived one, they've only prompted around one. They break things because they don't know the quirks of the product, the tribal knowledge that never made it into any doc. And yes, they introduce bugs that will sprout months down the road, in some edge case that only fires during a leap year in a customer's timezone.

All true. And all beside the point.

Because bugs existed before the vibers. Your kid had bugs under your watch too — I checked, everyone's did. The gatekeeping never bought you a bug-free codebase. It bought you slower bugs. The argument was never "bugs versus no bugs." It was always "bugs at what velocity, and how fast do you detect and resolve them." Bug management is a pipeline problem. You were treating it as a priesthood problem.

Which reveals what a senior is actually for, now. Not standing at the gate. Building the things that make the gate unnecessary: the test beds that catch the SDLC mistakes, the docs that encode the quirks, the observability that finds the leap-year bug before the customer does. The uncomfortable part? That's exactly the work the bottleneck-senior never prioritized. Undocumented quirks felt like job security.

They were. That's the problem.

The Title Trap

While your ego was guarding the codebase, two trades were quietly happening around you. One the company runs on you. One you run on yourself.

The company's move: titles over compensation. They can't pay market — or won't — so they mint you something shiny. Principal. Staff. Head of. A title costs the company exactly nothing; it's a string field in the HR system. You frame it on LinkedIn, they keep the salary delta, and everybody's happy in a transaction where only one side paid. Congratulations. You got compensated in metadata.

Titles are local variables. They're scoped to the company and garbage-collected the day your process exits. Money is the only value that serializes across employers.

Your move: the quick win. New team, new company, and you grab a fast, visible task. Ship it clean, plant the flag, prove your ground. And I'll say something unfashionable here: doing this once is wise. That's not politics, that's tactics — credibility is a currency and you need a starting balance.

Do it twice, and sorry bro, you are not winning material. You've become the guy who collects visible layups and dodges the hard, compounding work. The easy wins that felt like marking territory become the territory: shallow, decorative, and everyone above you can see it, especially the ones deciding your compensation.

One is strategy. Two is a pattern. Patterns get noticed.

And through all of it, one constant, non-negotiable, tattooed on the inside of your eyelids: never cut corners. Even the territorial quick win gets built properly. A flag planted on garbage is still garbage. With a flag.

Know Your Value. Then Earn It.

So where does this leave the old dev with the ego? Hopefully lighter. Because everything above tears down; this part builds.

Knowing your value is not entitlement. It's a contract you sign with yourself, and it has two clauses.

Clause one: know your actual market number. Not the number your title implies. Not the number your tenure suggests. The number the market pays for what you deliver. Research it. Then get paid it — in money, this quarter, not in strings and promises.

Clause two, the one people skip: back the number with performance. Get the job done. Keep the pace. Ship. Shine. That's why the compensation is proper — because it's collateralized by output, not by how long you've been sitting near the codebase. The market doesn't pay for guardianship. It pays for delivery.

And then, once the money problem is solved — and only then, this ordering matters — the real optimization starts. Pick the work that makes you better. Not the fancy title. Not the easy tasks. Not the quick wins that taste like progress and compound into nothing. Pick the hard, uncomfortable projects that force you to grow, the ones your ego avoids because it might look mid-level for a quarter while learning.

Because titles come and go. Money stays. And money pays the bills — but working on projects you love pays the cost of getting paid 😉 😉

The system will replace you. It replaced better engineers than both of us, and it did it on a Tuesday, before lunch. That was never the insult. The insult is spending your best years guarding a gate nobody needed, wearing a title nobody remembers, instead of knowing your number, earning it daily, and pointing the rest at work that makes you dangerous.

A man's got to know his limitations.

Now go pick up your kid from daycare. The human one. The other one is fine without you — and that, believe it or not, was always the goal.