A job that used to exist is creating punch cards for computers to read. Then keyboards and magnetic storage became a thing and fairly rapidly there wasn’t really this job anymore.

Likewise, due to the level LLM-powered coding assistants have gotten to, there used to be this job of writing code by hand. But now there sort of isn’t anymore.

The job that remains is—to me at least—10x more fun, and that’s managing LLM agents as they write code.

But management is famously hard.

There are many different failure modes when people start managing, but there’s one that gets basically everyone when they start out:

I’ll just do it myself, it’ll be faster

New managers almost without fail make this mistake at least a few times. Rather than coaching others, they decide to do it themselves.

Each time they do this, a few things happen:

  1. The would-be manager doesn’t learn more about managing
  2. The person they were managing doesn’t learn how to do something

Eventually—if they avoid the disillusionment that goes with this phase—they realize this doesn’t scale.

Commonly they then move to micromanaging.

I won’t do it for you, but I will tell you exactly how I want it done to an incredible level of detail

This is the most dangerous phase. They’re still doing most of the work, but it sort of feels like delegation. This is where new managers are at the greatest risk of burnout.

It’s the job of whoever is coaching and managing that new manager to guide them through these phases to the level where they’re really managing.

The same curve applies to managing LLM agents.

People start with autocomplete and move on to giving incredibly specific briefs where they’re still doing all of the thinking.

This feels sort of like using LLM coding agents. But it’s as far away from agentic coding as micromanagement is from true management.

It also comes with the same style of problems:

  • Every time someone does it, they sacrifice an opportunity to learn how to better collaborate with an agent to do it
  • Every time someone does it, they’re less likely to iterate on their environment and tools for collaborating with agents, they’re also less likely to optimize the codebase for agentic changes

So the single most important thing if we want to maximize the quality and rate at which we can deliver software is to work out the playbook for ramping engineers who previously thought of themselves as individual contributors to the point where they’re effectively managing LLM coding agents.

We know they are there when their process of building software looks much more like managing and collaborating with a team than it does writing code in an editor.

But it’s a strange dynamic now because you’re effectively either an apprentice who’s learning to do this, or a manager who’s established a base layer of competence in doing this. The “individual contributor” layer that’s existed for so long sort of doesn’t anymore.