Level 3
Directing
You run a team now — it just happens to be made of agents.
What's a level? How far you've shifted from writing code yourself to directing the AI that writes it — five bands, from hands-on-keyboard to running a fleet of agents. Most of us are mid-ladder, and climbing.
Where you are
Directing agents is your default, not your stretch. You spend your day writing specs, framing constraints, and reviewing output: choosing between drafts, redirecting when something's off, deciding what "done" and "good" actually mean. You're not in the loop for every line, and you've stopped wanting to be. The job is judgment, delegation, and taste.
What's keeping you here
Being too central. You're good at this, so the work routes through you: every spec, every review, every escalation lands on your desk. That feels like leadership; it's actually a bottleneck wearing leadership's clothes. If you're in every loop, you've built a system that scales to exactly one person: you. The next move isn't doing more of this better — it's designing so the work doesn't need you in the middle.
Why it matters now
When agents write the code, your real advantage isn't model access — everyone has that. It's the workflow you build around it: the evaluation framework, the feedback loops, the backpressure that catches errors before a human ever looks. That's a director's craft, and it's where the durable value now sits. Depth is the new differentiator, because breadth just got cheap for everyone.
What's different
You move from managing one agent well to designing how many agents coordinate. The question shifts from "is this output good?" to "is this whole system producing good output without me checking each piece?" You start building the conditions (backpressure, verification, the advisor pattern where a cheaper agent does the work and escalates only when stuck) rather than supervising the work directly.
The leadership shift
Now the leadership framing dominates outright. Your job is the one a good engineering manager has always had: unblock the work without being in the way, and make yourself unnecessary. You design the conditions under which the team (human and agent) decides for itself, and step in only when the system genuinely can't resolve something. Be the last resort, not the first. And the highest form of this isn't directing agents at all; it's growing the people around you across the same jump, because a director who only scales themselves caps out, while one who grows other directors multiplies.
Your moves
- Audit your loops: where are you the single point the work waits on? Engineer a constraint or a check so that loop closes without you.
- Build the backpressure layer deliberately (types, tests, schema validation, linters) so agents can run more autonomously and you review less by hand.
- Adopt the advisor pattern: let a cheaper, faster agent run the task end to end and escalate to a stronger one only when stuck, instead of paging yourself.
- Pick one person on your team and coach them across Level 5. Growing another director is higher leverage than directing one more agent yourself.
The best managers make themselves unnecessary — they design the conditions under which the team decides for itself, and step in only when the system genuinely can't resolve something. Agents are a team you're now managing; remove blockers without becoming one.
Next rung
Orchestrating: you stop directing agents one at a time and start running fleets of them, many agents, in parallel, in deliberate topologies. The unit of work jumps from "a task" to "a system of agents," and orchestration itself becomes the skill. (It's the top of Yegge's ladder, Level 8. But the framing that matters is the shift in the unit of work, not the number.)