Here’s a sentence I’ve caught myself saying, and I’d bet you have too: “It’s faster if I just do it myself.” For twenty years that was true, and it was a virtue. It’s now the most expensive habit in engineering.

Watch a strong engineer work the old way and it’s genuinely beautiful. Heads down, flow state, the editor a blur — one problem, one file, one thread of attention, moving faster than anyone around them. That’s the solo violinist: total command of the instrument, every note theirs, the whole performance riding on their two hands. We spent our careers getting good at that. We got promoted for it. And it is exactly the skill that no longer scales — because the thing it optimizes, single-threaded execution, is the part that just got cheap.

The violinist is still playing one instrument. Beautifully, sure. But there’s an orchestra sitting behind them now, instruments up, waiting for someone to actually conduct — and the violinist is so absorbed in their own part they haven’t turned around. Every hour they spend perfecting their line is an hour the other forty players sit idle. The performance isn’t bottlenecked on their skill anymore. It’s bottlenecked on their attention.

The unlock is a job change, not a productivity tip

The move everyone’s reaching for — “use AI to code faster” — keeps you at the violin. You’re still the one executing; the machine just hands you notes a little quicker. Marginally more output, same ceiling, same single thread. That’s not the unlock. That’s a faster hamster wheel.

The unlock is a change in what you do all day. You stop being the one who produces the work and become the one who directs it — you broadcast intent to a team of agents and let them execute in parallel while you hold the whole score in your head. Doing became directing. One thread became many, all in flight at once. And the currency you’re spending flips: it used to be your hours, one line at a time; now it’s your judgment, fanned out across everything running.

That flip has a name, and it’s worth stopping on before we build on it.

Old-world leverage was linear and cruel: your output was bounded by how fast your own hands moved, and the only way up was more hours or more skill at the instrument. Conducting breaks the bound. One well-formed intent can set five, ten, twenty agents working at once — and the load each one moves has nothing to do with how fast you type. You’ve swapped a lever the length of your arm for one the length of the room.

Spread your will, not your hours

Show me how a conductor actually works and the whole thing gets concrete fast.

You don’t play the second violin’s part for them. You don’t lean over and finger the cello. You express, precisely, what you want the music to be — tempo, dynamics, where it swells, where it goes quiet — and forty trained players turn that single expression into a coordinated performance. Your will reaches every stand at once. That’s the trick, and it maps cleanly onto agentic work: you write the intent, and the intent is what fans out.

I hold three or four threads live at once now, and none of them is me typing. One agent is refactoring a data layer against a spec I wrote this morning. Another is chewing through a test suite I pointed it at. A third is drafting the migration I described in four sentences. I’m not in any of those files. I’m reading output, correcting course, deciding what’s next — moving between stands, listening for the one section that’s drifting flat. My hours didn’t multiply. My will did. I spent one clear expression of intent and it’s currently moving three loads I couldn’t have touched in sequence in a week.

This is the part that trips up strong engineers hardest, and I get why — it feels like slacking. You’re not producing. Your hands aren’t on the keyboard. Every instinct a career of execution built into you says pick up the violin, you’ll do it better yourself. And for that one part, today, you might. But you’d be trading the whole orchestra for one perfect line — which is precisely the math that used to make sense and now doesn’t. Directing one agent is delegation. Directing many, holding the shape of all of them at once, is orchestration — and it’s a different job than the one you got hired for.

Leverage compounds — that’s the whole prize

Here’s where it stops being a productivity story and becomes a compounding one.

The hours you claw back from typing don’t just vanish into a longer lunch. They get reinvested — into more judgment, aimed at more threads. The time you’re not spending hand-writing a migration is time you spend writing a sharper spec, which lets you safely run another agent, which frees more attention, which funds another thread. Leverage feeds itself. Every hour returned to you buys more reach for your judgment, and more reach returns more hours. That’s a compounding curve, not a linear bump — and compounding is the only kind of advantage that actually pulls away from the pack over time.

The violinist can’t get on this curve. Their ceiling is fixed at the speed of their own hands — the best they can do is play a little faster this year than last. The conductor’s ceiling is the clarity of their intent and the number of threads they can hold, and both of those are trainable and both keep climbing. One of these people gets compounding returns on their time. The other gets a raise for practicing scales. This is the real reason the skill doesn’t map onto seniority: your most decorated executor can be dead last on the curve that now matters, and some quiet mid-level who’s allergic to ambiguity can be miles up it.

The failure mode is dropping the baton

None of this is free, and the way it goes wrong is specific enough to name.

Fan your attention across ten threads with no system underneath it and you don’t get leverage — you get a conductor who’s lost the score. Threads stall while you’re looking elsewhere. An agent quietly finishes and sits, done, waiting, because you forgot it was running. Another drifts off-spec for twenty minutes because nobody was reading it. You come back to a thread and can’t reconstruct what you wanted from it, so you re-derive it from scratch — and now the “leverage” cost you more time than doing it yourself would have. Spreading thin isn’t leverage. It’s just thin.

The thing that separates the two is externalized state. The conductor has a score on the stand — they are not holding forty parts in working memory, and neither should you. You need the written intent to live somewhere durable (the spec is the score), checkpoints so a stalled thread announces itself instead of dying quietly, and a way to reload context and know, at a glance, exactly where each agent stands. “I just keep it all in my head” is the tell of someone who’s never actually run more than one thread — the moment you’re conducting for real, your head is the wrong place to keep the score. Leverage without a system to hold the threads isn’t a superpower. It’s a dropped baton and a room full of musicians playing whatever they want.

This is also where the individual skill becomes a team problem, because the moment more than one person is conducting against the same shared context, your intent has to be legible to them too — which is a whole dimension of its own, and the subject I keep circling back to.

Put the violin down

The spine of all of this is one hard swap. The skill that got you here — fast, precise, single-threaded execution on one instrument — is not the skill that gets you leverage. Leverage comes from putting that instrument down, picking up the baton, and spending your judgment across a team instead of spending your hours on one line at a time. Write the intent once; let it move loads you’ll never touch. That’s the trade. It gives you back your time and hands you a lever the length of the room — but only if you build the system to hold the threads, and only if you can stand not being the one playing.

Which leaves the question I actually want answered: when you sit down to work tomorrow, are you reaching for the violin out of judgment — because this part genuinely needs your hands — or out of habit, because the orchestra behind you still feels like someone else’s to conduct?

---

This is Part 2 of Leadership in the Agentic Era. Part 1 — Acquiring Talent in the Age of AI — asked whether your interview loop still measures a job that exists. Coming next:

• 3 · Lean on the Tools — why review is the new bottleneck, and how specs, evals, and tests let you review lighter.
• 4 · Measure the Right Thing — the scrum metrics that lie in an agentic world, and what frontier teams track instead.