TL;DR: On October 26, Microsoft offered a voluntary exit package to roughly 60,000 employees, about a quarter of its workforce. The internet filed it under "AI is taking developer jobs." I read the announcement and the reporting, and I think that's the wrong lesson. This is a company moving money from people to data centers, and the tasks that are actually shrinking cut across job titles. Below: what was announced, what wasn't, which parts of developer work I see compressing in our own projects, a small script to see where your own week goes, and what I'd do if I were on the receiving end of an offer like this.
Every big tech workforce story now arrives with the same caption: AI did it. It's a tidy story, it gets clicks, and it makes every developer reading it a little more anxious. I think it's mostly wrong, and the way it's wrong matters if you're trying to decide what to learn next.
What Microsoft actually announced
Here's the primary source: Microsoft's own post announcing the Voluntary Exit Offer, written by Chief People Officer Amy Coleman. The key points, from that post and from what the company told reporters at CNBC, GeekWire and TechCrunch:
- It's open to eligible employees at level 70 and below in participating teams in the US, Canada, India and the UK. Some organizations are offering it and some aren't.
- About 60,000 people are eligible, roughly a quarter of a workforce Microsoft last reported at 223,000 (as of June 30).
- The package is described as equivalent to Microsoft's standard severance: pay based on tenure and level, continued stock vesting, healthcare for a fixed period, and career transition support.
- There's no age or tenure requirement, and the company says performance isn't a factor.
- Employees have until early December to decide; people who accept leave on December 31, according to CNBC's source.
- Microsoft told GeekWire the offer is not a replacement for layoffs, which remain part of its approach depending on business conditions.
It follows a voluntary retirement program earlier this year, which roughly 30% of about 8,750 eligible US employees accepted. Coleman told GeekWire that program reduced the size of the layoffs Microsoft announced in July.
Notice what's not in the announcement: any claim that AI has replaced the people being offered the exit. The memo talks about "changing needs" and flexibility. Microsoft's spokesperson told GeekWire it isn't a sign the company needs fewer employees.
You can be skeptical of corporate wording (I am), but you should be equally skeptical of headlines that put words into it.
The boring explanation: capital, not capability
CNBC framed the move as Microsoft trying to balance a costly AI infrastructure build-out with capital efficiency. That's the explanation I find most convincing, and it's a very different story from "the AI can do their jobs now."
When a company is spending heavily on GPUs, power and data centers, the pressure lands on the biggest line item it controls, which is people. That can happen even if the AI it's building hasn't replaced a single task those people do. Reporting via TechCrunch says divisions like Xbox, Windows, Copilot and Finance are participating, while groups like data centers, sales and marketing are excluded. That map looks a lot more like "where do we want to keep investing" than "which jobs can a model do."
Why does the distinction matter for you? Because the two stories lead to opposite career advice.
- If AI is replacing developers, the advice is "learn to prompt" or "get out."
- If companies are reallocating budget toward AI infrastructure and products, the advice is "be close to the work the budget is moving toward, and be the person who makes that spend pay off."
The second one is something you can act on.
Tasks shrink, not titles
The more useful question isn't "which roles are shrinking?" It's "which tasks inside every role are getting cheaper, and which aren't?" Titles are a lagging indicator. Tasks move first.
Here's what I see in our own work at Lycore, building custom software for clients. This is my honest read from our projects, not a survey.
Getting noticeably cheaper:
- First drafts of CRUD endpoints, serializers, forms and admin screens.
- Test scaffolding and the obvious cases (the non-obvious ones, less so).
- Translating code between languages and frameworks, and reading unfamiliar codebases.
- One-off scripts, data clean-up, regexes, SQL you write once.
- Boilerplate docs: docstrings, READMEs, changelog entries.
Not getting cheaper, sometimes more expensive:
- Working out what the client actually needs, and saying no to what they don't.
- Integrating with messy real systems: a legacy ERP, a payment provider's edge cases, a vendor API that lies about its own docs.
- Data migrations where the old data is wrong in ways nobody wrote down.
- Security review, and review in general. More generated code means more code to read.
- Running things in production: on-call, incidents, performance, cost.
- Owning a decision and being accountable for it six months later.
If most of your week sits in the first list, that's a real signal, whatever your title says. If most of it sits in the second list, the headlines are about someone else's job.
Find out where your own week goes
Gut feel is bad at this. Your commit history is better. This script reads git log --numstat and buckets lines changed into rough categories by file path, so you can see what kind of work you actually ship:
#!/usr/bin/env python3 # where_my_week_goes.py: rough breakdown of your own changes by kind of work import re import subprocess import sys from collections import Counter BUCKETS = [ ("tests", r"(^|/)(tests?|__tests__|spec)/|_test\.|\.test\.|\.spec\."), ("migrations", r"(^|/)migrations?/|\.sql$"), ("infra/config", r"(^|/)(\.github|deploy|infra|k8s|helm|terraform)/|Dockerfile|\.ya?ml$|\.toml$|\.ini$"), ("docs", r"\.(md|rst|txt)$"), ("frontend", r"\.(tsx?|jsx?|vue|svelte|css|scss|html)$"), ("backend", r"\.(py|cs|go|rb|java|kt|php|rs)$"), ] def bucket(path): for name, pattern in BUCKETS: if re.search(pattern, path): return name return "other" def main(author, since="90 days ago"): log = subprocess.run( ["git", "log", f"--author={author}", f"--since={since}", "--no-merges", "--numstat", "--format="], capture_output=True, text=True, check=True, ).stdout totals = Counter() for line in log.splitlines(): parts = line.split("\t") if len(parts) != 3 or parts[0] == "-": # skip binary files continue added, deleted, path = parts totals[bucket(path)] += int(added) + int(deleted) grand = sum(totals.values()) or 1 for name, lines in totals.most_common(): print(f"{name:14} {lines:8} lines {lines / grand:6.1%}") if __name__ == "__main__": main(sys.argv[1] if len(sys.argv) > 1 else "") python where_my_week_goes.py "you@example.com" It's crude on purpose. Lines changed are not effort, and the most valuable thing you did last quarter might have been a two-line fix after three days of debugging. But it does answer one question honestly: how much of what I ship is the kind of code an assistant now writes a decent first draft of?
Then do the part the script can't. Look at your calendar for the same 90 days and ask what share went to things that aren't commits: design discussions, incident calls, reviewing other people's changes, talking to users. That's the half of the job the "AI layoffs" story ignores.
If you're offered a package like this
I've never been on the receiving end of a Microsoft offer, so take this as a developer's checklist, not financial or legal advice. Talk to an actual adviser about your own situation.
- Read it as a market signal about your team, not about you. Microsoft says performance isn't a factor. Whether your organization chose to participate says something about where it plans to invest.
- Ask what happens if you say no. The company has said layoffs remain on the table. A voluntary package now and a possible involuntary one later are different deals, and you're allowed to compare them.
- Price the unvested stock and the healthcare gap. Those two details usually matter more than the headline weeks of pay.
- Check the market for the work you actually do, using the breakdown above. "Senior engineer" covers very different jobs. "Senior engineer who owns payments integrations and on-call" is a much easier sell than "senior engineer who mostly wrote internal CRUD."
- Don't decide during the news cycle. There's a window until early December. The worst version of this decision is the one you make on day two because of a viral thread.
What I'd tell a developer who isn't affected
Most of us don't work at Microsoft. But big-company moves set the tone for budgets everywhere, so a few things I'd do anyway:
- Move toward the second list. Volunteer for the integration nobody wants, the migration with bad data, the on-call rotation, the security review. That's the work that stays expensive.
- Get good at reviewing generated code fast. If assistants make first drafts cheap, the bottleneck becomes the person who can tell, quickly, whether a draft is safe to merge.
- Be able to explain cost. Companies moving money toward AI want people who can say what a feature costs to run and whether it's worth it. That skill is rare and very easy to demonstrate in an interview.
- Keep shipping things end to end. Owning a feature from the conversation with a user to the dashboard in production is the opposite of a task that compresses.
The takeaway
A 60,000-person buyout is a big, real thing, and I don't want to downplay what it means for the people deciding by December. But "AI replaced them" isn't what was announced, and it isn't the most likely explanation either. What's happening is slower and more useful to understand: budgets are shifting toward AI infrastructure, and inside every developer role, some tasks are getting cheap while others aren't. Titles will follow the tasks, not the headlines.
So audit your own week, and move toward the work that doesn't get cheaper.
Question for you: when you look at your last three months honestly, how much of your work is the kind an assistant now drafts well? And has that changed how you're planning your next role?


