Every few months someone says management is dead. Now the argument has numbers behind it: companies cutting layers, AI taking over work managers used to do by hand, teams asking whether they still need someone whose job is not directly writing code.
The better question is narrower: which parts of management are dying?
The part in trouble is the middle layer that mostly routes information. Take a plan from above, break it into tasks, collect status, turn the status into a deck, repeat. AI is good at that kind of work. It can summarize the tracker, draft the update, find the blocker, produce the dashboard, and keep every stakeholder looking at roughly the same picture. When a manager's main job is moving information around, the role is easy to compress.
The work of management does not disappear. It moves closer to the decisions that shape the work before it becomes tickets.
The wrong replacement
One answer many tech companies are trying now is the player-coach: a hybrid role where someone is primarily an IC, but also carries coaching responsibilities, often for a large number of direct reports. In theory, this keeps managers close to the work while preserving the human side of management.
In practice, the role is muddy. Are you an IC who also coaches? A manager who occasionally codes? A tech lead with performance-review authority? The person gets pulled in both directions and cannot lean far enough into either one. The IC work suffers because people need support. The coaching suffers because the person still has their own deliverables. The team gets a part-time manager and a distracted IC.
That is not a clean answer to AI. It hides a management cut inside a new title.
The real issue is not whether managers should also write code. It is that AI changes the cost of trying things. When the cost of generating work drops, the cost of choosing the wrong work goes up.
Cheap execution is not free
When execution is expensive, teams naturally spend a lot of time making sure execution happens. Who owns this? Is it staffed? Is the ticket clear? Is the estimate real? Are we blocked?
Those questions still matter, but they are no longer the scarce part. AI can turn a rough idea into a branch. It can draft the migration, write the first pass of the test suite, summarize the codebase, produce the release notes, and keep retrying while you sleep. The marginal cost of "try it" keeps falling.
That is useful. It is also dangerous.
More code is not free just because the first draft was cheap. It adds APIs, states, dependencies, migrations, tests, alerts, permissions, customer promises, edge cases, and future meetings. It gives the team more surface area to own. A bad idea is still bad if an agent implements it quickly.
This is where managers become more important, not less. Not because they decide the roadmap alone. They should not. Product, design, engineering, data, support, and customers all hold pieces of the truth. The manager is uniquely positioned to connect those pieces and apply AI across them: prototype the idea, pressure-test the design, inspect the technical cost, summarize customer evidence, compare options, and ask what complexity the team is about to inherit.
The work moves from "is everyone busy?" to "are we creating the right work?"
What gets automated, what gets harder
I wrote down the manager work I see in a normal week. The split is not subtle.
| Old manager work | What happens to it now |
|---|---|
| Weekly status rollups | AI can draft them from tickets, docs, commits, and meeting notes |
| Stakeholder update decks | AI can assemble the first pass and keep it current |
| Meeting notes and action items | AI already does most of this |
| Ticket grooming and triage | AI can sort, summarize, and propose next steps |
| First drafts of reviews and process docs | AI can produce a usable draft |
| Roadmap tradeoffs across product, design, and engineering | Harder, because there are more plausible options |
| Complexity control | Harder, because generated code increases surface area quickly |
| Coaching and accountability | Still human, and still context-heavy |
| Knowing when not to build | More valuable as building gets cheaper |
The disappearing work is mostly coordination. The durable work is judgment: shaping the roadmap, protecting focus, setting the quality bar, and knowing when the team is about to turn a cheap prototype into an expensive commitment.
That judgment has to be technical enough to see the cost, close enough to customers to see the value, and close enough to the team to know what pace is real.
The human work still matters
Teams never had managers just for logistics. People doing hard things together need someone whose job includes the team itself: noticing when a strong person has quietly checked out, starting the conversation nobody wants to start, taking ambiguity from above and turning it into something the team can act on.
A model can't sit across from an engineer who's about to quit and work out whether they need a new challenge, a real break, clearer feedback, or just ten minutes of being heard.
The data backs this up. Employees who feel their mental health is supported are roughly twice as likely to report no burnout, and manager support measurably weakens the link between emotional labor and burnout. Even people predicting deep cuts admit algorithms can't provide psychological safety.
But empathy is not enough to justify the role. A manager is not a therapist, and being warm and available is not a business model. The job is to notice patterns, start hard conversations, raise the bar, and connect people to real support when they need it. The human work matters most when it is attached to the work: what the team is building, why it matters, what tradeoffs are being made, and what load people are carrying.
How managers need to change
The manager who survives this shift gets out of the coordination middle and moves toward three things.
Technical judgment. Not "learn to code" from scratch, and not pretending to be an IC. The point is AI fluency, not tool fluency: knowing which workflows to redesign, where a human has to stay in the loop, what is actually hard versus what only looks hard, and when a generated implementation is buying speed by selling future maintainability.
Customer and product judgment. When execution gets cheaper, taste matters more. Managers need to understand the customer, the product bet, and the design intent well enough to help separate the boring valuable thing from the exciting distraction. AI can generate five plausible approaches. Someone still has to know which one fits the product and the people using it.
Subtraction. The manager's job is not to keep the machine busy. It is to keep the team pointed at work that should survive contact with reality. That means saying no, narrowing scope, deleting zombie projects, and asking whether a feature should be a process change, a support macro, a docs page, or nothing at all.
None of this makes the manager a solo decision-maker. It makes them a better synthesizer. The role sits at the intersection of product, design, engineering, customer context, and team capacity. AI gives that person more ways to explore the space. It does not remove the need for judgment.
So, is management dead?
No. The status-update, never-touches-the-work version is dying. The player-coach replacement does not solve the problem either; it just asks one person to be an IC and a manager at the same time, usually with too many people depending on them.
AI makes doing cheaper. That makes the roadmap more important. The managers who last are the ones who can use AI across disciplines, protect focus, control complexity, understand customers, and still do the human work that keeps a team intact.
The version that does not survive is the one that stays in the middle and calls that leadership.