The most common job transformation of the next decade is not that people get replaced. It is that individual contributors become managers — not of people, but of agents. The competencies that used to define a manager's job — delegation, precise specification, verification of work you did not do, exception-handling, and ownership of the outcome — are about to become the core skills of almost every role. That is a forecast, and I'll argue both for it and against it. If it is even directionally right, it changes what you should be practicing this quarter.
Today, most people do the work. A marketer writes the post. A developer writes the function. An analyst runs the query and builds the chart. Tomorrow — and in pockets, already — more people direct agents that do the work: the marketer defines a brief and runs a fleet of content agents, the developer orchestrates coding agents against a spec, the analyst points research agents at a question and audits what returns. Each of these is the same job underneath. It is management: getting work done through others and standing behind the result, applied to a new kind of "other."
Getting things done through others, minus the others
The oldest one-line definition of management, credited to Mary Parker Follett, is "the art of getting things done through people." The agent shift subtracts the last word and keeps the structure intact. You still specify, delegate, review, handle the exceptions, and own the outcome. You just do it with software workers instead of human ones.
This is not the centaur pattern, and the difference matters. After losing to Deep Blue in 1997, Garry Kasparov championed "advanced chess," later "freestyle" — a human and an engine reasoning over the same position, one move at a time. That is collaboration on a single task: the centaur is one mind and one machine co-producing one output. Managing agents is a different shape. You are not co-reasoning one artifact; you are handing whole tasks to semi-autonomous workers and certifying what they return. Centaur chess is a craftsman with a better tool in their hands. Agent management is a foreman with a crew on the site. The tool-user and the foreman are not exercising the same skills, and most individual contributors today are trained as the former.
The three examples are one transition
Walk each one concretely, because the abstraction hides how much actually changes.
The marketer stops writing every post. The new work is upstream and downstream of the writing: compose the brief — voice, allowable claims, hard constraints, worked examples of good and bad — spin up content agents across channels, and then do the genuinely hard part, reading the output adversarially to catch the off-brand line, the invented statistic, the subtly wrong call to action, before it ships under their name. The typing skill depreciates. The editorial-judgment and brief-writing skills appreciate.
The developer stops writing every function. They write specs and tests, dispatch coding agents, and review diffs. This one is already visible in daily practice: the bottleneck migrates from producing code to reading it, and the scarce person is the one who can look at a change they did not author and know whether to trust it.
The analyst stops running every query by hand and directs research agents, then has to verify a synthesis assembled from sources they never personally read — the hardest verification problem of the three.
Strip the domains away and the residual is identical: specify, delegate, verify, own. That is the manager's task list. The reason it lands on everyone is structural. Once you see that agents dissolve jobs into tasks rather than swallowing jobs whole, and that agents take the automatable tasks, the human work necessarily clusters at the seams — the specification going in and the verification coming out.
Delegation and specification transfer first
The skills that carry over cleanly are the front half of management: deciding precisely what to ask for. An underspecified brief produces garbage, and agents produce it faster and more confidently than any junior ever could. The scarce competence is translating a vague want — "make the churn dashboard better," "write our launch announcement" — into an executable specification a worker with no shared context can run against and you would sign the result. Managers have always been sorted by this. Some hand a report a crisp, bounded, checkable task; others hand over their own confusion and are surprised by what comes back. With agents the gap widens, because the agent will never push back the way a good human report does when the ask is incoherent. Specification stops being a management nicety and becomes the load-bearing skill of the role.
Verification at scale is the new hard part
The genuinely new skill — the one most individual contributors have least — is verifying work you did not do. When you produce the work yourself, verification is continuous and nearly free: you trust the output because you built it and watched every step. When an agent produces it, you are handed a finished, plausible artifact and asked to certify it with none of the context that producing it would have given you. That is a different and harder cognitive act, and it does not come bundled with the doing.
The arithmetic is unforgiving. A human manager supervises maybe five to eight reports, and crucially, most verification is delegated back down: competent reports self-check, own their mistakes, and tell you when something is wrong. Agents do not reliably do this. They emit confident, fluent output whether it is right or wrong, and they do not raise their hand. So the review burden per "report" is higher, while the number of agents one person nominally directs runs to twenty, fifty, a hundred. Put numbers on it. If verifying a single artifact takes ten minutes — not skim, verify — and thirty agents each turn out a few of them a day, that is fifteen-plus hours of verification alone, before you have specified anything new or handled a single exception. Generation collapsed toward zero cost. Verification did not. The binding constraint of the whole system becomes how fast one human can produce trusted sign-off, which is exactly the constraint I traced through the structure of the AI-native org chart.
This is why raw productivity claims mislead. Producing ten times the drafts is not ten times the output if you can only certify one of them; the surplus piles up in a review queue as unverified liability. The high-leverage move, for anyone managing agents, is to drive down the cost of verification: demand output that ships with diffs, provenance, tests, citations, and explicit abstention — the agent saying "I am not confident about this figure" instead of smoothing over it. The best agent managers will invest as much in making output checkable as in making more of it.
Exceptions and accountability stay human
Two pieces of the manager's job resist automation for reasons that are not about current capability.
Exception-handling has always been the core of supervision — the process covers the median case, and the manager exists for the tail it does not. Agents mirror this precisely: strong on the common case, brittle on the weird input, the ambiguous call, the situation that needs a judgment the training distribution never posed. The human residual is the tail.
Accountability is the deeper one. You own the agent's output. When it ships a wrong number to the board, "the model said so" is not a defense that survives contact with anyone senior. The name on the work is yours, which means the buck stops at a human whether or not that human wrote a line of it. This is structural, not a temporary gap that a better model closes: an agent has no capital at risk, no license to lose, no reputation that suffers when the call is bad. Someone who can actually be made to bear the loss must stand behind the output, and standing behind the output of others is the definition of a manager.
The part people will not like
Many people became individual contributors precisely to avoid managing. The IC track exists because a large number of excellent engineers, analysts, writers, and researchers looked at management — the reviewing of other people's work, the delegating, the owning of outcomes you did not personally produce — and chose to keep making the thing with their own hands. The agent transition does not honor that choice. It makes nearly everyone a manager regardless, because the individual-contributor job itself becomes delegation — to agents rather than to juniors. The temperamental cost is real and rarely discussed: the flow of doing the craft yourself is partly traded for the more anxious posture of directing and checking. Some of the best makers will find they signed up for the one job they spent a career avoiding.
The strongest counterargument
The honest objection is that this describes a transitional decade, not a destination. If agents keep improving, they will eventually verify their own work, handle their own exceptions, and coordinate their own sub-agents — and then the human manager's seat disappears too, making "manager of agents" as temporary a role as "switchboard operator." This is the fast-takeoff view: capability climbs steeply enough that agents become trustworthy without human review. It deserves a fair hearing because it might be correct. Nick Bostrom's instrumental-convergence argument even sharpens it: a sufficiently capable agent pursuing a goal has generic incentives to gather capability and remove obstacles, and a human reviewer is, in that frame, an obstacle to route around — while the orthogonality thesis warns that "highly capable" carries no built-in preference for keeping you in the loop.
Two reasons I still bet on the management decade, stated as a bet and not a certainty. First, accountability does not automate. You can build an agent that checks another agent, but you cannot build one that can be held liable — that has capital at stake, a license to lose, a name that takes the damage. As long as someone must bear the loss when the output is wrong, a human sits atop the stack owning it, and that is the job. Second, the transition is not instantaneous. The slow-takeoff case, which is my base rate, keeps verification human-gated for years precisely in the high-stakes domains where the work is worth the most — medicine, finance, anything with legal exposure or a named party who must answer for the result. The manager-of-agents decade is robust across a wide range of takeoff speeds. Only the far tail erases it, and even there it erases the IC who does the work first.
What to build now
Treat delegation, specification, and verification as universal skills to train, not optional ones for people on the management ladder.
- Specification. Practice writing a brief so precise that a worker with no context — human or agent — can execute it and you would sign the result unread. If you cannot specify it, you cannot delegate it, and you are about to delegate everything.
- Verification at scale. Deliberately practice checking work you did not produce: review code you did not write, edit prose you did not draft, reproduce an analysis from its output alone. This is the muscle individual contributors have least, because doing-it-yourself let them skip it their whole careers.
- Accountability. Put your name on agent output and treat its errors as your errors. The muscle is built by carrying consequences, not disclaiming them.
One caution against over-delegating, drawn from learning science. Robert Bjork's research on "desirable difficulties" shows that the effortful struggle you remove is often the struggle that builds and retains the skill; retrieval practice and productive difficulty are what make competence durable rather than brittle. Delegate every rep to agents and you lose the tacit judgment that let you verify their work in the first place — you decay into a manager who can no longer tell correct output from confidently wrong output, which is the most dangerous manager there is. Keep enough hands-on reps to stay a competent verifier. Delegate the volume; keep the judgment.
The question that used to define your career was whether you were good at the work. The question that is about to define it is whether you can be answerable for work you did not do.