Published on

They cut the staff to buy the GPUs. Then the systems broke.

Authors

Listen to this article · They cut the staff to buy the GPUs. Then the systems broke.

0:00 / 0:00

Watch this article · They cut the staff to buy the GPUs. Then the systems broke.

The trade looked clean on a spreadsheet: reduce headcount, redirect the saving into compute. A GPU is a line item that scales with the plan, and a team is a cost that argues back.

A number of companies that made that trade are now hiring back the people they let go — not all of them, and often not into the same seats, but enough of them that the pattern is visible. The reason is not that anyone changed their mind about AI. It is that the systems those teams ran did not become simpler when the teams left.

2
major Microsoft service outages in fifteen days in November 2026 — the case that made the argument concrete
15days
between them, with Exchange, Teams, SharePoint, Copilot 365 and Defender all affected
130k
Outlook problem reports in the United States alone during the second outage

What an outage actually is

An outage is rarely one broken thing. It is a cascade that starts somewhere and spreads through dependencies nobody has drawn on a diagram: a configuration that only one region uses, a retry loop that interacts with a queue depth, a certificate that expired because a calendar invite went to a mailbox nobody reads any more.

Fixing it fast is not a matter of intelligence. It is a matter of knowing which of forty plausible causes is the real one, and that knowledge is usually held in a specific way — not in a runbook, but in a person who has seen this before, or who knows a person who has.

That is the part the spreadsheet missed.

  1. Cut to fund compute

    Headcount becomes a saving, and the saving becomes GPU capacity. The plan closes.

  2. The knowledge leaves with them

    Not the documented procedures — the exceptions, the workarounds, the names of the people to call.

  3. Something breaks

    The cascade follows dependencies that were never written down, in an order nobody predicted.

  4. Hire back

    Not everyone. The ones who know where the bodies are buried, often as contractors or on new terms.

The loop companies are running. The fourth step is the expensive one, because it buys back knowledge that was free a year earlier.

The knowledge that is not in the runbook

Ask an operations engineer to write down their job and you get the procedures. What you do not get is the part that matters at 3am: that the third retry always fails on this queue, that the vendor's status page lags by twenty minutes, that a particular dashboard is lying because of a timezone bug from 2019 and everyone knows to read it differently.

None of that is sabotage or laziness. It is what expertise looks like. It accumulates through incidents, and it is transmitted by proximity — sitting next to someone, overhearing the call, watching which log they open first.

An AI can read the documentation. It cannot overhear the call it was not on, and it cannot know a person who knows a person. When the team is gone, the system keeps running on the parts that were written down, and fails on the parts that were not.

What the runbook holds, and what walks out of the door

The other side of the argument

Anthropic's chief executive has put the counter-case, and it deserves to be stated fairly. If building software becomes cheap, more software gets built — which means more people are needed to finish, host and maintain what was started. Coding becomes a commodity; shipping stays a craft. On that reading the near term brings more engineering work, not less.

He has also said he expects that to be temporary: as the models improve, the finishing work shrinks too, and the number of people needed falls again, sharply.

  1. Now: cheaper to build

    Anyone can produce a working prototype. Demand for people who finish and run them rises.

  2. Later: cheaper to finish

    The models take over more of the finishing. The demand curve turns over.

  3. Either way: the tacit layer

    The last thing to be automated is knowing why this system misbehaves — the part held in people.

The two horizons in the argument, and the part that survives both.

What this actually tells a company

Three things follow, and none of them is "keep everyone forever".

The saving was borrowed, not earned. Cutting a team does not remove the cost of running the system; it moves it to the day the system breaks, at a worse price and without warning. The bill arrives as an outage, a rehire premium, and a customer who remembers.

Documentation is not the fix either. Writing more runbooks helps, and it is what everyone says. But the knowledge that fails under pressure is the knowledge nobody thought to write down because it was obvious to the person who knew it. The reliable way to keep it is to keep the person, or to keep someone they trained.

The rehire is the honest signal. When a company pays to bring back the same people, it is stating what the asset was. Not the servers, not the licences, not the model subscription — the people who could tell you what was about to break.

The fight is not AI against jobs. It is explicit knowledge against tacit knowledge, and the second one is still expensive to buy back.

Source: ABN Asia's reporting on the November 2026 Microsoft outages (two service failures in fifteen days; 130,000 Outlook reports in the United States during the second), and public remarks by Anthropic's chief executive on the near- and medium-term effect of AI on engineering employment. The rehiring pattern is described qualitatively; no company-level figures are asserted.

Contact: [email protected]