A Fork in the Road: Scalable Intelligence or Mirage?

Opening: The Warning Nobody Wanted

Approximately a year ago, I warned people to stop cheering on AI as if it were an unqualified victory for workers.

The reaction was not thoughtful disagreement. It was techno-optimism with a conference badge: the machine would bless everyone, lift all boats, make every worker more powerful, and maybe also do the dishes if prompted with sufficient optimism.

Some of us could see the power grab hiding inside the productivity sermon, so forgive me for not clapping.

A year ago, workers were told AI was augmentation. Techno-optimism sold the upside as universal, while the downside was treated as bad manners.

Now the layoffs are no longer theoretical.

The Layoff Signal

Cloudflare announced a roughly 20 percent workforce reduction while reorganizing around an “agentic AI-first operating model.”[1]

Block announced more than 4,000 cuts, nearly half its workforce, as part of an AI overhaul.[2]

Atlassian announced about 1,600 cuts, roughly 10 percent of its workforce, while shifting toward AI and enterprise sales.[3]

Coinbase announced about 700 cuts, roughly 14 percent of its workforce, as part of an AI-driven restructuring.[4]

The Usual Giants Are Here Too

Amazon’s CEO has said generative AI and agents should reduce the company’s total corporate workforce over the next few years, and Reuters has also reported large Amazon corporate reductions in waves.[5][6]

Meta has planned large reductions while redirecting spending toward AI infrastructure.[7][8]

Microsoft has cut thousands of employees, offered voluntary buyouts, and continued funneling large capital expenditures into AI and cloud infrastructure.[9][10][11]

Not every layoff is caused by AI, because companies also cut for high rates, weak demand, overhiring, investor pressure, consolidation, failed bets, and plain executive panic wearing a new hat.

But the story has changed: a year ago, workers were told AI was augmentation, while now workers are being told AI is the operating model.

The Real Fork

The real question is not whether AI is useful, because it clearly is, and I use it constantly.

The real fork is whether AI is a path to scalable intelligence or whether AI is a mirage: if intelligence can keep scaling through more hardware, more data, more agents, more reinforcement, and more orchestration, then the labor reset may be permanent; if the scaling story breaks, then the current phase may be acute, destructive, and painful, but the fever eventually breaks.

Neither branch is comfortable for workers, because the difference is not whether pain arrives but how long the pain lasts.

The Bet Behind the Boom

The AI industry is making a specific wager: intelligence can be scaled by adding more hardware, more data, more tools, more agents, more context, more reinforcement, and more orchestration.

If the model is not intelligent enough today, add compute; if it drops intent, add memory; if it fails at planning, add an agent loop; if it hallucinates, add a verifier; and if the verifier fails, add another verifier.

The bet is that if the industry can fake enough intelligence for long enough, the imitation will eventually harden into the real thing.

Why the Bet Matters

If the bet is right, the economic consequences are enormous because AI does not merely assist workers; it keeps improving until more categories of work become mechanically compressible.

Under that scenario, layoffs beget layoffs, demand weakens, labor bargaining power falls, and the old economy built around paid human participation begins to unravel.

If the bet is wrong, the present wave still hurts because companies can still overcut, workers can still be displaced, and demand can still weaken before the fever breaks.

The two futures differ because, in the mirage scenario, firms eventually rediscover that generated output is cheap while durable ownership, verification, trust, and product convergence remain expensive.

Scenario One: AI Is Scalable Intelligence

If AI continues scaling into broadly reliable intelligence, this shift is not temporary, and double-digit layoffs become early signs of a permanent labor reset rather than opportunistic cost cutting.

In that world, companies learn that smaller teams can produce enough output to satisfy markets, so they cut mechanical roles first, then coordination roles, then support layers, then management layers, and eventually any job whose value can be approximated, routed, or checked by a smaller number of humans supervising machines.

The named human remains, but the broad labor class shrinks.

The Labor Shape Under Scalable AI

The junior pipeline weakens because AI handles more scaffolding, mid-level roles compress because AI eats the repeatable execution layer, and senior roles remain but increasingly become review, risk, integration, and boundary-setting positions.

This is not a world without humans; it is a world with fewer humans in the loop and more responsibility concentrated on those who remain.

The Game Theory Problem

From a game-theory perspective, each company has an incentive to move first, because if one company cuts while competitors keep hiring, the cutter may improve margins while still selling into a market funded by everyone else’s payroll.

Once many companies cut at the same time, the logic changes because workers are not only costs; workers are also demand.

Demand Destruction

Laid-off workers spend less, insecure workers spend less, contractors raise prices or narrow scope, employees stop volunteering ownership, households defer purchases, startups become harder to fund, SaaS seats disappear, and recruiting, training, support, internal tooling, and digital services all lose circulation.

A single firm can cut its way to better margins, but an entire economy cannot cut itself into abundance.

If This Scenario Is Right

If AI is truly scalable intelligence, the old advice becomes blunt: get closer to physical systems, learn repair, learn trades, and build competence in areas like plumbing, welding, electrical work, marine systems, energy systems, care work, food systems, logistics, security, compliance, and infrastructure.

The practical response is to own tools, own property if possible, own your context, and own something that cannot be fully compressed into a prompt.

That does not mean software disappears. It means software starts to look like news corporations in the age of AP reporting, Twitter, and platform distribution: still everywhere, still influential, still producing output, but much harder to run profitably as a broad labor-intensive industry. A few institutions may remain profitable or strategically protected, like Fox News and maybe CNN. The rest fight over shrinking margins while the product becomes increasingly abundant and increasingly difficult to monetize.

Scenario Two: AI Is a Mirage

The other possibility is that AI is not useless, but that the scaling story is overstated.

This is not the claim that AI is fake, because AI clearly drafts, summarizes, scaffolds, translates, explains, writes code, generates tests, and helps people move faster in bounded contexts.

The mirage is the belief that these gains compose cleanly into durable intelligence.

The ARM Loan Shape

The more I use AI, the more I see a pattern that looks less like a miracle and more like an adjustable-rate mortgage.

The teaser rate is speed, while the balloon payment is verification.

At first, AI feels cheap because it gives you a draft before you have finished thinking, code before you have opened the docs, and ten possible product directions before you have decided whether the product deserves one.

Then the adjustment period arrives.

The Verification Payment

You have to check whether it preserved state, remembered the constraint from three turns ago, avoided breaking the last known good behavior, worked outside the visible case, and preserved an architecture that still makes sense.

To be fair, none of this is entirely new in software, because developers have always reviewed code, teams have always tested patches, and software has always had regressions, edge cases, half-working scripts, and the occasional function that appears to have been written by a raccoon under deadline pressure.

The difference is the role shift.

From Developer to QA for an Industrious Intern

You are no longer only the developer; you become QA for a very industrious intern.

The intern is fast, tireless, and capable of building scaffolding, wiring up components, generating tests, drafting CSS, sketching APIs, and producing code that looks plausible before lunch.

That is useful, but it becomes a trap when volume is mistaken for convergence.

The faster the intern generates, the more you must inspect.

The Prompt Loop Cost

Your prompt takes multiple turns, the token count rises, the context grows, and the model starts optimizing for the latest correction while quietly dropping older constraints.

You restate requirements that were already stated, paste the last known good version, explain again which behavior must be preserved, and receive another polite apology followed by another branch of reality to audit.

At that point, the bottleneck has not disappeared; it has moved from typing code to supervising generated code, from implementation to inspection, and from craft to triage.

The Balloon Payment

At the end of the day, you may still only partially own the code, because ownership does not come from seeing output; ownership comes from struggling with the system until its semantics become part of your working memory.

That is the balloon payment.

AI can show you the shape by producing the outline, the surface, the file structure, the plausible component, the reasonable function name, the expected handler, and the standard pattern.

But seeing the shape is not the same as owning the semantics.

The 80 Percent Illusion

The “80 percent done” illusion becomes dangerous because AI can get you to something that looks 80 percent complete very quickly, while that 80 percent is not equivalent to code you personally struggled through.

You may understand the surface, the intent, and even the broad architecture, but you do not fully own the local semantics because the code did not become part of your working memory through friction.

The difference is like watching someone weld, cook, or code on YouTube versus doing the thing yourself. The former is observation, and often entertainment. The latter is embodiment. You learn where the metal warps, where the pan burns, where the abstraction leaks, and where your own assumptions fail because your hands are in the system and the system pushes back.

That remaining 20 percent becomes harder than it looks.

It is like finishing food that is already 80 percent cooked, except you did not choose the ingredients, control the heat, or see when the sauce started to break. It is like finishing a weld that is already 90 percent done, except you do not know how hot the metal got, where the bead is thin, or whether the earlier pass contaminated the joint. It is like finishing code that arrived almost complete before you had time to watch it form.

This is not like YouTube learning, where you at least observe the process and build a rough mental model from the sequence. With AI, the apparent 80 percent can happen so fast that even observation gets skipped. You receive the artifact, not the formation history. Good luck finishing the last part without knowing which invisible mistakes were baked into the first part.

The Two Different 20 Percents

Imagine being dropped into a legacy project that is 80 percent complete and being told to finish the last 20 percent, then compare that with finishing the final 20 percent of a domain and codebase you built yourself, where every awkward decision, broken abstraction, naming compromise, and defensive branch carries memory.

Both are “20 percent,” but they are not the same 20 percent.

In the first case, the work is discovery because you must infer why things exist, which pieces are safe to change, which behavior is accidental, and which ugliness is load-bearing.

In the second case, the work is completion because you already know the semantic terrain and are polishing a system whose resistance you understand.

What the Studies Suggest

This is why AI-assisted work can feel productive while still slowing experienced developers in mature systems.

The METR 2025 study on experienced open-source developers found that developers expected AI tools to make them faster, but in familiar mature repositories, AI assistance increased task completion time.[12]

That finding does not prove AI is useless; it shows the gap between generated shape and owned semantics.

A later METR-adjacent open-source study points in the same direction from another angle: AI-assisted programming increased output mainly through less-experienced peripheral developers, but the generated work required more rework.[13]

The burden moved toward experienced core developers, who reviewed more code while producing less original code themselves.[13]

The Edge Accelerates, the Center Pays

The more interesting failure mode is that the organization gets more apparent output at the edge, then taxes the center.

Productivity appears to rise because more code enters the system, but the scarce resource becomes senior attention: review, correction, integration, judgment, and preservation of standards.

If that attention is already overloaded, the system has not become more efficient; it has merely moved the payment date.

Shape Versus Semantics

Semantics live in the parts that do not show up cleanly in the prompt: why state belongs here, why an edge case matters, why a callback cannot fire twice, why a CSS rule is defensive, why a storage key cannot be renamed, why the previous implementation looked ugly but survived production, and why the thing that seems redundant is actually load-bearing.

A human who writes the code by hand may move slower, but the struggle builds compression because every mistake becomes context, every fix becomes memory, and every awkward branch becomes a clue.

You learn not only what the system does, but why it resists certain changes.

AI can skip that struggle, which is the appeal, but skipping struggle also skips part of the ownership formation.

Why Convergence Can Still Be Slow

When generated code breaks, you may recognize the general shape without knowing the local physics.

You know what it is supposed to be, but you do not fully know why it became this.

That makes debugging slower, review heavier, and refactoring more uncertain.

This is why AI productivity can feel real while wall-clock convergence remains disappointing: you are offloading labor, but you are also importing ambiguity.

You get code faster than you get understanding.

That gap is manageable when the work is disposable, bounded, or easy to verify, but it becomes expensive when the system is long-lived, stateful, or close to the core of the business.

The old software problem was that humans were slow and inconsistent; the new software problem is that machines are fast and forgetful.

Different disease, same hospital.

Why This Could Be a Mirage

There are several reasons the present AI boom could be acute rather than permanent. None of them prove AI is fake, because that claim would be too easy and too wrong. The stronger argument is that AI may be genuinely useful while still failing to become the unlimited scaling engine its investors and evangelists need it to be.

The mirage would not be the tool. The mirage would be the extrapolation.

1. Bounded Work Is Not Product Ownership

The strongest productivity gains appear in bounded work such as writing, support, boilerplate, scripts, tests, summaries, and structured tasks where correctness is visible quickly.

The strongest positive studies tend to come from professional writing tasks, customer-support workflows, and structured coding-assistant field experiments rather than mature-repository ownership.[14][15][16]

That work matters, but it is not the same as owning a mature product system. A support answer, a first draft, a test scaffold, and a small internal script can often be judged quickly. A mature product system has memory, constraints, customers, history, edge cases, and state.

Confusing these categories makes the spreadsheet look cleaner than the software.

2. Mature Software Is Mostly Context

Core repositories contain years of decisions, constraints, hidden invariants, broken migrations, customer-specific exceptions, operational scars, and “never do that again” knowledge.

A model can generate code inside that system without truly owning the system. It can infer patterns from the code it sees, but it does not necessarily know which patterns are intentional, which are accidental, and which are ugly because production made them ugly.

This distinction matters because mature systems are not only collections of files. They are accumulated negotiations between product, operations, customers, compliance, outages, deadlines, and prior mistakes.

AI can read the artifact. It does not automatically inherit the scar tissue.

3. Validation Helps, But It Also Hardens Assumptions

The obvious answer is to add more validation, more tests, more guardrails, and more checks. That helps, but it is not a free rescue.

Validation and tests are like pouring concrete into a foundation. They stabilize the structure by making certain assumptions hard. Once that concrete turns into a slab, things do not move easily. That is the point. A good test suite freezes important behavior so future changes cannot casually erase it.

But this creates a second problem when AI enters the system. When you ask AI to change software, you are often asking it to change the structure without fully preserving the semantic ontology behind the structure.

The model can see code, tests, and patterns. It can produce plausible modifications. But it does not necessarily know which behaviors are core axioms, which are incidental artifacts, which tests represent sacred invariants, and which tests are merely fossilized accidents from three rewrites ago.

4. Failing Tests Still Need an Owner

Once AI changes the system, some tests may fail. The hard question is what the failure means.

Did the test fail because the change correctly invalidated an old assumption? Did it fail because AI introduced a regression? Did it fail because the test was too brittle? Did it fail because the previous behavior was wrong but depended on by users? Did it fail because the model changed shape while missing semantics?

That is where the word “regression” becomes less obvious than it sounds. A regression is not merely “a test failed.” A regression is a violation of intended continuity. But intended continuity lives in the product’s semantics, not only in the code and not only in the test suite.

If you embodied the building process, you are better able to answer that. You remember why the test exists, which compromise created it, which behavior was intentional, and which ugly branch is holding up the building.

5. Circular Ownership Is Not a Stable Foundation

If you did not embody the process, you ask AI. Then the circular logic begins.

You ask the model whether the failing test represents an outdated assumption or a real regression. But the model is an LLM. It does not own the system. It only knows what you provide in context. The context is partly in the code, partly in the tests, partly in commit history, partly in scaffolding, partly in prior conversation, and partly in the human memory that never got digitized.

The latest semantic changes may not be carried completely by any one artifact. The code shows what exists. The tests show what has been frozen. The prompt shows what was recently requested. The model output shows what was generated. None of these necessarily owns the meaning.

That is the trap: validation can harden behavior, but it cannot by itself decide which hardened behavior is still true. More tests can reduce ambiguity, but they can also preserve yesterday’s misunderstandings. More AI review can explain the failure, but only from the context it has been given.

Welcome to circular ownership, where everything has evidence and nothing has custody.

6. Software Can Harden in the Wrong Way

Can software be developed this way? Sure, under one condition: eventually it stops being soft.

A system can absorb ambiguity for a while. It can tolerate generated scaffolding, brittle tests, partial ownership, accidental coupling, and a few “temporary” shortcuts that immediately begin applying for permanent residency. That already happened with human teams. Humans have always created scars, accidental architecture, write-only code, and cargo-culted patterns that nobody wants to touch after the original author leaves.

That part is not new. What is new is speed and mandate.

AI accelerates the production of these artifacts, and corporate pressure increasingly turns that acceleration into policy. The problem is no longer only that one rushed developer took a shortcut under deadline pressure. The problem is that entire organizations may normalize a workflow where meaning is inferred after the artifact exists, ownership is reconstructed after the change lands, and tests are treated as the only surviving witness.

At that point, software hardens in the wrong way. It becomes less like a flexible medium and more like poured concrete around partially understood assumptions. You can still modify it, but every modification requires drilling into old decisions while hoping you do not hit rebar, plumbing, or some cursed conduit nobody documented because the AI-generated comment said “TODO: clarify later.”

7. Generation and Verification Scale Differently

Producing plausible output is cheap, but proving that the output preserves the local world is expensive.

In real systems, the hard part is often not writing the patch. It is knowing where the patch should not go. It is knowing which behavior is sacred, which behavior is accidental, which behavior is ugly but necessary, and which behavior is only there because nobody had time to fix it.

AI is strongest when the correctness signal is immediate. It is weaker when correctness depends on continuity across time, interpretation of intent, or knowledge of why the system became this shape in the first place.

This is why more generation does not automatically become more progress. At some point, the system is no longer constrained by typing speed. It is constrained by the cost of knowing whether the generated artifact still belongs in the world it entered.

8. AI Encourages Option Explosion

When everything is easy to start, too many things get started, and Plan A through Plan Z all become possible.

That feels like progress until none of them converge. AI lowers the cost of beginnings, but it does not eliminate the cost of selection, ownership, or finishing. A person can spend a week generating branches, variants, mockups, scripts, and half-products, then realize the actual product shape is still unresolved.

This is one of the more seductive traps because the work looks active. There are artifacts everywhere. There are screenshots, diffs, prototypes, and summaries. But artifact production is not the same as strategy.

Winning local battles does not mean you are winning the war.

9. AI Can Hide Skill Decay

A weak understanding can produce polished language, a junior can sound senior, and a shallow design can look fluent.

Organizations may mistake articulation for competence, output for ownership, and speed for judgment. That is dangerous because the surface signal improves while the underlying understanding may remain thin.

This does not only affect hiring. It affects reviews, promotions, planning, vendor evaluations, and architecture discussions. If everyone can sound like they understand, the cost of determining who actually understands goes up.

The result is signal inflation. More people can produce the appearance of competence, while the number of people who have lived through the consequences may not increase at all.

10. AI Shifts Work Onto Scarce Experts

AI can shift work onto the people least able to absorb more.

If peripheral developers generate more code, core developers may spend more time reviewing, correcting, and protecting the system. The edges accelerate while the center pays.

The METR-adjacent open-source study points toward this pattern: AI-assisted output increased mainly through less-experienced peripheral developers, while experienced core developers reviewed more code and produced less original code themselves.[13]

That is not automatically organizational efficiency. It may be a transfer of burden from generation to review, from the visible edge to the exhausted center.

11. Burnout and Trust Loss Distort the System

Burnout is not a soft concern because burned-out workers review worse, mentor less, warn less, care less, and recover slower. Like old rubber stretched too thin, they stop springing back.

Trust loss changes worker behavior too. If companies treat workers as replaceable execution units, workers stop donating stewardship and become contractors in spirit, even when they remain employees on paper.

They demand clearer scope, more pay, more flexibility, and less invisible responsibility. That is not irrational. It is a predictable response to a weaker bargain.

If companies want ownership, they have to pay for ownership. Otherwise they get bounded labor, defensive behavior, and thinner institutional memory.

12. The Productivity Story Mixes Different Work

A support workflow, a sales email, a prototype, a bash script, and a core entitlement refactor are not the same economic object.

Averaging them together makes the spreadsheet look clean and the system look smarter than it is. A 30 percent gain in bounded support work does not imply a 30 percent gain in mature product engineering. A faster prototype does not imply faster convergence. More code does not imply more durable product value.

If this is the true fork, then the current wave still causes pain because companies can overcut before the evidence settles, workers can lose jobs before the fever breaks, and demand can weaken before leadership admits the limits.

The eventual correction may restore some demand for human judgment, but not before a lot of damage is done.

The Keynesian Problem

Both scenarios run into the same economic issue: labor is demand.

A company sees payroll as cost, while the economy sees payroll as circulation.

Under a Keynesian lens, broad labor compression reduces purchasing power, and if AI-driven cuts spread across enough companies, demand destruction follows.

How Demand Thins

Laid-off workers consume less, anxious workers consume less, and people delay houses, cars, tools, subscriptions, travel, education, and risk.

This matters especially in the digital economy, because much of it is seat-based and confidence-based.

Fewer workers means fewer software seats, fewer teams means fewer tools, fewer startups means fewer cloud accounts, and fewer secure households means fewer experiments.

Early firm-level evidence also suggests that firms exposed to online labor markets have begun substituting AI spending for contracted online labor spending, which supports the idea that labor compression is not merely theoretical.[17]

Why Demand Destruction Can Hide Temporarily

Demand does not disappear all at once; it thins.

That thinning can be hidden for a while by investor spending, debt, AI infrastructure buildout, and remaining workers absorbing more load.

But those are not the same as broad, healthy demand.

If everyone cuts, the customer base eventually notices that it has been fired.

The Worker’s Problem

I do not have perfect certainty, and I cannot see the future.

The best I can do is what I try to do in my Pareto planning work: map scenarios, assign rough probabilities, examine constraints, and ask what actions survive across multiple futures.

Maybe AI keeps scaling, maybe it hits a wall, maybe it becomes powerful in some domains and stubbornly mediocre in others, maybe the economy restructures cleanly, and maybe the transition is ugly.

But if you are a worker, very little here reads as good news.

Duration, Not Direction

If AI is real in the strongest sense, the shift is permanent and labor demand falls structurally.

If AI is a mirage, the pain may be acute rather than permanent, but the fever still has to break.

Companies may still overcut, morale may still collapse, demand may still weaken, and workers may still pay the transition cost.

In one scenario, the pain lasts because the machine keeps improving; in the other, the pain lasts until companies admit the machine did not improve enough.

Either way, dependency becomes the risk.

The Third Option

That is why I think the practical answer is not to wait for the correct prophecy.

The practical answer is to hedge by reducing dependency, lowering fixed costs, building practical skills, owning tools, owning infrastructure where possible, cutting consumerism, using renewable power where practical, and avoiding debt traps, including cognitive debt traps created by too much AI-generated complexity.

Treat corporations as counterparties rather than parents, and use AI where the cost is bounded without confusing generated output for durable freedom.

Arpeggio as Hedge

This is what I am trying to explore with Arpeggio.

I have been building a more resilient life aboard a solar-powered boat: a habitat that floats, moves, produces power, and supports local AI from ambient sunlight.

I have installed and repaired many of the systems myself.

It is not a universal prescription, because everyone does not need to live on a boat, and frankly most people should not unless they have developed a suspiciously high tolerance for bilge water, wiring diagrams, and weather.

But the direction matters because resilience is not retreat; it is optionality.

What Arpeggio Points Toward

At Arpeggio, the focus is practical decoupling: solar power, marine systems, local AI, resilient planning, technical tools, and ways to reduce dependence on fragile economic assumptions.

The goal is not to escape society into fantasy.

The goal is to own more of the load-bearing systems of daily life, so that when the road forks, you are not standing barefoot on asphalt waiting for a corporation to explain your future in a memo.

Closing

The American economic system may not end tomorrow, and it may not end at all.

But the bargain is changing.

Workers were told AI would augment them, and now companies are cutting workers while telling investors AI will let smaller teams do more.

That might be true if AI keeps scaling, or it might be a mirage if verification, ownership, and convergence remain stubbornly human.

Either way, workers absorb the risk first.

So hedge by decoupling where you can, building what you can, and owning what matters.

The sea is vast. The power is free. The AI is local.

The road has already forked, and neither branch is good, only less bad.

The only sensible option may be to leave the road until visibility returns.

---

References

[1] Reuters. “Cloudflare to cut about 20% workforce as AI adoption reshapes operations.” May 7, 2026. Verified source for Cloudflare’s roughly 20 percent workforce reduction, the “agentic AI-first operating model” framing, and restructuring charges.

[2] Reuters. “Jack Dorsey’s Block to cut nearly half its workforce in AI overhaul, shares surge.” February 26, 2026; updated February 27, 2026. Verified source for Block’s more than 4,000 announced cuts and AI-overhaul framing.

[3] Reuters. “Atlassian to cut roughly 10% jobs in pivot to AI.” March 11, 2026. Verified source for Atlassian’s roughly 1,600 cuts, about 10 percent of its workforce, and stated pivot toward AI and enterprise sales.

[4] Reuters. “Coinbase to cut about 14% of workforce in AI-driven restructuring.” May 5, 2026. Verified source for Coinbase’s roughly 700-job, 14 percent workforce cut and AI-driven restructuring framing.

[5] Amazon. “Update from Amazon CEO Andy Jassy on Generative AI.” June 17, 2025. Primary-source statement that generative AI and agents are expected to reduce Amazon’s total corporate workforce over the next few years.

[6] Reuters. “Amazon axes 16,000 jobs as it pushes AI and efficiency.” January 28, 2026. Verified source for Amazon confirming 16,000 corporate job cuts and roughly 30,000 corporate cuts since October.

[7] Reuters. “Meta planning sweeping layoffs as AI costs mount.” March 14/17, 2026. Verified source for reports of planned Meta layoffs linked to AI infrastructure costs and AI-assisted efficiency expectations.

[8] Reuters. “Meta targets May 20 for first wave of layoffs; additional cuts later in 2026.” April 17/20, 2026. Verified source for Meta’s reported first wave of roughly 10 percent cuts and additional later cuts.

[9] Reuters. “Microsoft to cut about 4% of jobs amid hefty AI bets.” July 2, 2025. Verified source for Microsoft’s roughly 4 percent workforce reduction amid heavy AI infrastructure spending.

[10] Reuters. “Microsoft plans first voluntary employee buyout, CNBC reports.” April 23, 2026. Verified source for Microsoft’s first voluntary employee buyout program.

[11] Reuters. “Big Tech investors to gauge payoff as AI spending set to hit $600 billion.” April 28, 2026. Verified source for the broader AI capital-expenditure pressure across major hyperscalers and the link between AI spending, cash-flow pressure, job cuts, and buyouts.

[12] Becker, Joel; Rush, Nate; Barnes, Elizabeth; Rein, David. “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity.” METR / arXiv:2507.09089, 2025. Verified source for the randomized controlled trial of 16 experienced open-source developers across 246 tasks in familiar mature repositories; developers expected AI to speed them up but actually took longer with AI assistance.

[13] Xu, Feiyang; Medappa, Poonacha K.; Tunc, Murat M.; Vroegindeweij, Martijn; Fransoo, Jan C. “AI-assisted Programming May Decrease the Productivity of Experienced Developers by Increasing Maintenance Burden.” arXiv:2510.10165, 2025. Verified source for the finding that AI-assisted productivity gains in OSS were driven mainly by peripheral developers, while core developers reviewed more code and saw reduced original-code productivity.

[14] Noy, Shakked; Zhang, Whitney. “Experimental Evidence on the Productivity Effects of Generative Artificial Intelligence.” Science, 2023. Verified source for the writing-task experiment finding reduced completion time and improved judged output quality when participants used ChatGPT.

[15] Brynjolfsson, Erik; Li, Danielle; Raymond, Lindsey R. “Generative AI at Work.” Quarterly Journal of Economics / NBER Working Paper No. 31161, 2023–2025. Verified source for the customer-support field study finding productivity gains, especially among less-experienced workers.

[16] Cui, Kevin Zheyuan; Demirer, Mert; Jaffe, Sonia; Musolff, Leon; Peng, Sida; Salz, Tobias. “The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers.” Management Science, 2026. Verified source for randomized field experiments at Microsoft, Accenture, and a Fortune 100 company finding increased completed developer tasks under AI coding-assistant access.

[17] Stevens, Ryan. “Payrolls to Prompts: Firm-Level Evidence on the Substitution of Labor for AI.” arXiv:2602.00139, 2026. Verified source for firm-level evidence that companies exposed to online labor markets increased AI spending while reducing spending on contracted online labor.