How a senior engineer directs AI agents without becoming a babysitter

You've met both engineers.

The first one adopted AI and somehow got slower. He reads every line the agent produces, rewrites half of it, second-guesses the rest, and by the time he's done he might as well have typed the whole thing himself. He's not directing an agent, he's babysitting one, and it shows in his velocity.

The second one adopted AI and got faster in the worst way. He merges whatever comes out, ships it, and moves on. You already know how that story ends, because you spent last quarter cleaning it up.

Both of them missed the actual job. Directing an agent isn't watching it, and it isn't ignoring it. It's something in between that almost nobody names, and it happens to be the thing senior engineers are already good at.

Directing is setting conditions, not watching output

Think about how a good tech lead works with a strong junior team.

They don't hover over every keystroke, and they don't toss a vague ticket over the wall and hope. They set the thing up so good work is the likely outcome: a bounded problem, the right context, clear constraints, and a checkpoint at the moment that actually matters. Then they let people work.

That's the whole move, and it maps almost perfectly onto agents. The senior who's fast with AI isn't the one with the cleverest prompts. It's the one who's good at shaping the work so the agent has a real shot at getting it right, and who knows exactly where to look when it's done.

Prompting is a party trick. Direction is the skill.

What direction actually looks like

Strip away the mystique and it's a handful of unglamorous habits.

You decompose before you delegate. You don't tell the agent "build the feature," because that's how you get a confident, plausible, subtly wrong 600-line PR. You break the problem into pieces small enough that correctness is obvious, and you hand those over. The decomposition is the senior work. The typing is not.

You front-load the context. Half of what makes agent output bad is that the agent didn't know the thing you know: the weird constraint in the billing service, the reason that module is the way it is, the pattern the rest of the codebase follows. A senior loads that in up front instead of correcting for its absence forty times after the fact.

You review at the seams, not the lines. Here's where the babysitter loses. Reading every line is the slowest, least valuable form of review, and it's what you do when you don't trust the setup. Direction means you review the decisions: the interface, the data model, the edge cases, the places where being wrong is expensive. You let the agent own the volume and you own the judgment.

You make the tests the contract. If the only way you can trust the output is to read all of it, you haven't built leverage, you've built the world's slowest pair-programming session. Tests are how you verify outcome without auditing every keystroke. Good ones let you trust a lot of code you didn't personally read, which is the entire point.

You know when to take the wheel. Some problems are gnarly enough, or load-bearing enough, that a senior just does them. Part of direction is recognizing those in advance and not handing them to an agent to save fifteen minutes and lose a weekend.

The value was always judgment

Notice what none of that is about. It's not about the tool, and it's not about who can coax the fanciest output out of a model this week.

It's about knowing what good looks like, catching what's wrong before it costs you, and being the person accountable when it ships. That's judgment, and judgment is the thing you can't download. A junior with the best agent in the world still doesn't know which 600-line PR to be suspicious of. A senior does, and that instinct is exactly what turns raw AI output into something you can actually put in front of users.

The agent brings speed and volume. The senior brings taste and ownership. Take either one away and you've got a worse version of the whole thing.

The tell

Here's the quiet test for whether you're directing or babysitting.

Did your velocity go up after you brought AI in?

If it went down, you're babysitting. You're using a leverage tool as a very expensive autocomplete, reviewing everything, trusting nothing, and paying the coordination cost without collecting the payoff. If it went up and the quality held, you're directing, and you've quietly become more valuable than you were before, not less.

That's the part the "AI is coming for engineers" crowd keeps getting backwards. The engineers it makes obsolete are the ones whose only skill was output. The ones who had judgment just got a lever long enough to move a lot more with it.

The agent doesn't need a babysitter. It needs a cristal-clear spec and a world-class leader.