Why delegation feels like betrayal (and how to do it anyway)

Delegation is one of those words that sounds like a neutral management skill until you try to do it and realize it’s… emotional.

Like, irrationally emotional.

When I was in the Marines, one of my first formal fitness reports as an NCO said I was exceptional and needed to improve my ability to delegate. That was over 15 years ago now, which is rude. But what’s weirder is that the note is still basically correct.

I’m a staff engineer now, and delegation is still one of my biggest struggles. Not because I don’t understand it. I understand it intellectually. I understand it the way you understand exercise: “yes, this is good for me, in theory.” The problem is that delegation isn’t just a technique. It pokes at identity. It touches old wiring. It feels like betrayal.

Delegation is a loaded word

Part of the problem is that “delegation” is a catch-all term for at least three totally different things:

1. Task swap: “Can you do this so I can do something else?”
2. Work packaging: “Here’s a larger effort; I’m breaking it into pieces and assigning them.”
3. Ownership transfer: “You own this area/outcome. I’ll support, but you’re driving.”

Those are not the same skill. They don’t feel the same. They don’t require the same level of trust. And they don’t create the same kinds of failure modes.

Looking back at that first fitness report, what “delegation” meant in that context was mostly tagging people—assigning tasks downward. It was closer to management mechanics than what most staff+ engineers are talking about today. There wasn’t a lot of ambiguity or massive scope at my level back then. The work didn’t demand the same kind of “delegate an outcome and accept a different path” muscle.

Today it does. Constantly.

The real reason delegation feels gross

I’ve always leaned toward “lead by example.” I don’t want to ask someone to do something I wouldn’t do myself, or couldn’t do myself. I also genuinely enjoy the weeds. I like being able to dive down sharp, build, debug, ship.

So when people say “you need to delegate more,” my brain translates that into:

“Tell someone else to do the annoying work because your time is more valuable.”

And that translation triggers something deep in me. Because I’m a self-reliant person by default. Delegation can feel like telling someone their time matters less than yours.

Intellectually, I know that’s not what it means. Emotionally… we’ll get to that.

The other real reason delegation is hard is simpler: it threatens the systems that made you “safe” earlier in life.

For me, competence was my shield. Self-reliance was my charter for survival.

When you build your identity around “I can handle it,” handing things off isn’t just uncomfortable. It’s threatening. It’s messing with your foundational load-bearing beams.

So yes: delegation can feel like betrayal. Betrayal of your standards. Betrayal of your identity. Betrayal of the story you’ve told yourself about how you’re valuable.

And that’s why “just delegate more” is terrible advice.

The staff engineer version: you’re not dumping work, you’re shaping it

Here’s the reality of staff-level leadership (especially as a tech lead):

You define the shape of the work. Other engineers execute.

That’s not hierarchy. That’s leverage. That’s how an organization works when it’s functioning.

And the weird twist is: the more senior you become, the less your job is “be the best doer,” and the more your job is:

• clarify intent
• make tradeoffs explicit
• reduce ambiguity
• build alignment
• unblock
• and create conditions where others can do great work

Delegation, done well, is not a way to do less. It’s a way to scale your impact beyond what your own hands can produce.

But—crucially—knowing that intellectually and absorbing it emotionally are two different things.

If delegation hurts, it usually means you’re delegating the wrong thing the wrong way

A lot of delegation pain comes from mismatches:

• You delegate a task, but you secretly want them to own the decisions.
• You delegate “ownership,” but you keep all the authority.
• You delegate an outcome, but you don’t give context or constraints, so the outcome becomes a guessing game.
• You say “take this,” but what you mean is “do it like I would do it,” which is not delegation—it’s remote-control engineering.

Here’s a sentence I wish more of us would tattoo on our foreheads:

If you delegate the task but keep all the decisions, you didn’t delegate—you created a ticket.

And if you delegate ownership but keep rewriting their work, you didn’t delegate—you adopted.

A simple model: three levels of delegation

This is the only delegation taxonomy I’ve found that actually reduces suffering.

Level 1: “Do exactly this”

Use when:

• stakes are high
• time is tight
• the person is new to the domain
• constraints are strict

You’re basically giving a recipe. That’s fine. Sometimes it’s correct.

Level 2: “Achieve this outcome”

Use when:

• the person has competence
• you want them to grow
• you want to retain strategic control but not micromanage execution

They propose a plan. You review for risks and alignment. They execute.

Level 3: “Own this area”

Use when:

• you want compounding leverage
• you’re building durable leadership capacity
• the person is ready for true ownership

You set direction and boundaries. They make decisions. You review outcomes.

Most “delegation failure” is expecting Level 3 behavior while delegating with Level 1 clarity—or the opposite: delegating Level 3 responsibility but only granting Level 1 authority.

The delegation playbook (for people who hate delegation)

The goal isn’t to become a delegation robot. The goal is to delegate without feeling like you’re abandoning quality or disrespecting people.

1) Delegate a unit of ownership, not a pile of tasks

Instead of:

• “Can you update these files and push the config?”

Try:

• “Can you own the rollout plan for X, including validation and rollback?”

Ownership creates meaning. Tasks create resentment (in both directions).

2) Provide intent, not just instructions

People can’t read your mind. And your mind is often the problem.

Share:

• why this matters
• what success looks like
• what failure looks like

3) Give constraints as guardrails, not solutions

Instead of:

• “Do it using pattern A, with structure B.”

Try:

• “Must be backwards compatible, observable, and low-risk to roll back.”

This is how you stop being the bottleneck and protect quality.

4) Make the feedback loop about risk, not status

Check-ins shouldn’t be “are you done yet?”

Pick milestone gates that de-risk the work:

• scope and approach chosen
• key unknowns resolved
• PR drafted
• rollout plan ready
• metrics/alerts in place

This keeps you out of the weeds while still keeping the project safe.

5) Ask for a plan, not an update

Ask:

• “What’s your plan?”
• “What are the top 3 risks?”
• “Where are you least confident?”

If you always accept vague updates, you’ll either micromanage later or get surprised at the worst possible moment.

6) Let “different” be acceptable if it meets intent + constraints

This is the ego work.

If the output:

• hits the outcome
• respects constraints
• has a reasonable quality bar

…then “not my way” is not a defect. It’s evidence that other people are capable adults.

7) Do a quick retro after the handoff

Ten minutes. No drama.

• What context did I forget to share?
• What assumptions did I make that weren’t obvious?
• What would make this easier next time (template, checklist, doc)?

This is how delegation becomes a system instead of a recurring emotional event.

The uncomfortable truth: delegation forces you to grieve an identity

If you’ve spent your life being self-reliant—if competence was your shield—then delegation can feel like stepping into an exposed place.

Because it’s not just “someone else does the work.” It’s:

• you’re no longer the hero
• you’re no longer the fixer
• you’re no longer getting constant proof that you’re valuable via direct output

Leadership doesn’t remove accountability. It changes where accountability lives.

And the hard shift at staff level is this:

Your value moves from “what you can personally produce” to “what outcomes you can make inevitable.”

That shift feels threatening when your nervous system learned early that “I can handle it myself” is how you survive.

So if delegation feels hard, you’re not broken. You’re predictable.

A small exercise (if you want to actually change)

Three journaling prompts I like (because they’re annoying in the right way):

1. When I avoid delegating, what am I protecting—quality, speed, or identity?
2. What work am I hoarding because it proves I’m competent?
3. What constraint or check-in would make delegating this feel safe?

Try this experiment for one week:

• Delegate one outcome (not a task).
• Schedule two risk-based check-ins.
• Write down the assumptions you had that you didn’t actually communicate.

If you do nothing else, do that.

Closing

Delegation doesn’t mean you do less. It means you stop requiring your hands to be the limiting factor on impact.

But yeah—emotionally—it might still feel like betrayal.

What’s the hardest thing for you to delegate, and what story do you tell yourself about why?