Most people assume AI helps individual contributors the most. They’re closer to the code. They ship more often. They’re already “on the tools”. That assumption makes sense. It’s also incomplete. There’s a quieter pattern showing up: engineering managers and team leads are often getting more leverage from AI than they expected. Not because they’re better engineers. But because the job trained them for this kind of work.

The Problem

A lot of people treat LLMs like a faster Google search or a junior developer who happens to be cheap and available. That works for small tasks. It starts to fall apart once the work gets ambiguous, long-running, or risky. At that point, output volume goes up, but confidence goes down. Some people stall there. Others keep moving.

Why This Matters

AI doesn’t reward raw speed as much as it rewards structure. If you can break work down, run things in parallel, and put checks around uncertain output, you move quickly without losing control. If you can’t, you mostly generate more material to sift through. The difference compounds faster than people expect.

EMs Are Used To Building Quality Control, Not Trusting Output

If you’ve managed engineers for any length of time, you’ve internalised one idea:

Output is cheap. Confidence is earned. You don’t rely on people “getting it right”. You build systems that make failure visible. That’s what compilers, linters, CI pipelines, code review, and human review (QA, verification and validation) exist for. Not because engineers are bad, but because humans are fallible. LLMs fit cleanly into that worldview.

There’s also a difference in when quality control happens.

Many ICs are used to checking work line by line, keystroke by keystroke. The feedback loop is tight and immediate. With AI, especially when you’re orchestrating larger chunks, the loop stretches out. You let it run. You review later.

That can feel uncomfortable. It feels like loss of control.

EMs are more used to this rhythm. You delegate a body of work, let it progress, and review at defined checkpoints. You resist the urge to micromanage every detail because you simply can’t scale that way.

AI rewards the same restraint. Let it produce. Then evaluate. Then refine. Another unreliable component. Another thing to wrap with guardrails.

EMs Already Know How To Delegate Work They Won’t Do Themselves

This is the bigger advantage, and it has nothing to do with prompts. Engineering managers spend their days:

taking unclear problems and cutting them into pieces,
separating dependent work from independent work,
deciding what can run in parallel,
and accepting that some effort will be wasted. That is exactly how you get leverage from LLMs. You don’t ask one model to “do the task”. You spin up multiple threads. One explores. One drafts. One reviews. One looks for edge cases. Some outputs are useful. Many aren’t. That’s fine. If you’re used to delegating to people, delegating to machines feels natural. If you’re not, it can feel inefficient or sloppy. AI rewards people who are comfortable with that mess.

Context Switching Is A Feature, Not A Bug

There’s another advantage hiding in plain sight: context switching. For many ICs, context switching is the enemy. It breaks flow. It slows deep work. It’s something to minimise. For EMs, it’s normal. You move between problems all day. Strategy, people issues, architecture questions, stakeholder updates. You’re rarely in one thread for long. Orchestrating multiple AIs looks similar. You’re holding several partial outputs in your head, nudging one forward, reviewing another, discarding a third. It’s less about deep flow and more about active coordination. If you’re already comfortable switching contexts without losing the bigger picture, you have a quiet advantage here.

EMs Are Comfortable With Non-Deterministic Systems

There’s a deeper point underneath all of this. AI is non-deterministic. You can give the same input twice and get different outputs. That frustrates a lot of engineers, especially when AI is pitched as “just a higher-level programming language”. It isn’t. Managing humans has never been deterministic either. You give a task to two capable engineers and you’ll get two different implementations. Neither is exactly what you pictured. Both require review. Both require iteration. Over time, you learn how to reduce unnecessary loops. You get better at:

setting expectations clearly,
specifying what really matters,
leaving room where it doesn’t,
and building guardrails so mistakes are caught early. You also learn something less technical: you stop being emotionally surprised by imperfect output. Iteration becomes normal. Refinement becomes part of the plan. Disappointment isn’t a crisis; it’s just feedback. That mindset transfers almost perfectly to working with LLMs.

If you love deterministic systems, this shift can feel uncomfortable. Writing code gives you tight feedback loops and precise control. Orchestrating humans or AI stretches that loop out. The control becomes indirect and the results vary. That isn’t worse. It’s a different mode of work, and one that trades precision for leverage. If you’ve spent years scaling your impact through people, you already understand that the work won’t come back exactly as you imagined. The goal isn’t perfection on the first pass. The goal is forward motion with control. In that sense, AI feels less like writing code and more like managing a very fast, very literal junior team.

A Small Anecdote

Earlier this year, I knocked out a few pieces of fairly standard business work. The kind of thing that normally drags across months because it keeps getting deprioritised. I didn’t do anything clever. I just treated AI like a team I didn’t fully trust. I split the work up, ran things in parallel, reviewed aggressively, and threw a lot away. The surprising part wasn’t the speed. It was how little emotional energy it took once the process was in place.

This Isn’t About EMs “Winning”

This isn’t an argument that engineering managers are better than ICs. The people who will do best with AI are the same people who always did well:

they care about output,
they notice inefficiency,
and they want to move faster than the default. AI doesn’t create that mindset. It amplifies it. People with low agency or a “minimum viable effort” approach might see a small boost. Then they level off. People who already push for leverage keep pulling ahead.

What ICs Should Take From This

If you’re an IC, this isn’t a warning shot. It’s a skill gap you can close. The missing skill usually isn’t “prompting”. It’s:

decomposing work intentionally,
delegating parts of a problem away,
and putting quality checks between you and the output. Those are learnable. Start small:

Split work before you start prompting.
Run multiple attempts instead of searching for the perfect one.
Treat AI output like unreviewed code.
Optimise for effectiveness, not elegance. You don’t need a management title to work this way.

A Trap Worth Calling Out

There is one familiar danger for EMs. AI makes it easier to jump into execution and get short-term wins. That temptation doesn’t go away just because the tool is better. You can now do more yourself. Faster. The long-term leverage still comes from building repeatable workflows and teaching others, human or otherwise. AI doesn’t remove that trade-off. It sharpens it.

The Takeaway

If you’re an EM thinking AI probably isn’t meant for you, it’s worth another look. You may already have the right instincts. If you’re an IC feeling behind, don’t start with prompt tricks. Start with delegation. Take one piece of work this week and deliberately break it into parallel, AI-assisted chunks. Expect waste. Expect to throw things away. That’s where the leverage is.