From Sanskriti Khandelwal | Product & Market Analysis

Meta Project OT: Code Changes Up 220%, User-Facing Changes Up 36%

On this page

Meta's internal data showed code changes to its internal platforms up 220% in a year, while changes that reached users rose only 36%. Those Meta Project OT figures, reported by Reuters in August 2026, are the clearest public gap yet between AI-assisted code output and shipped features. Read carefully, they show a measurement problem. They do not show that AI agents broke Meta.

Key takeaways

  • Meta's code output rose 3.2 times faster than its shipped features. Internal posts reported by Reuters put code changes to internal platforms up 220% year over year and user-facing changes up 36%.
  • Per change shipped, Meta's incident rate was roughly flat. Major incidents rose 40% against a 36% rise in user-facing changes, which works out to about 3% more incidents per user-facing change.
  • The reporting does not establish that AI agents caused the incidents. The incidents are not itemised, and nothing published says whether the comparison controlled for system growth or other changes.
  • The strongest signal is time spent firefighting, not incident count. Response time rose 70% against a 40% rise in incidents, so each incident took about 21% more staff time to handle.
220%Year-over-year rise in code changes to Meta's internal platforms and infrastructure. Source: internal post cited by Reuters, August 2026.
36%Rise in changes that put new or upgraded features in front of users, same period. Source: Reuters, August 2026.
40%Rise in major technical and security incidents from the previous year, directional. Source: internal posts cited by Reuters, August 2026.

What Reuters actually reported about Meta Project OT

Project OT was Meta's internal plan to make parts of the company "AI native". Reuters reported that Mark Zuckerberg and his senior team developed it at a leadership retreat in January 2026. Meta later confirmed it to Reuters as a year-long project focused on cost cutting, redesigning team structures and moving staff into new priority areas.

The plan explored scenarios in which some teams shrank by as much as 60%. Meta disputes how that figure has been read. It told Reuters the 60% applied to scenario planning for certain teams, never to the whole workforce, and that "we didn't move forward with every scenario from the exercise."

The four numbers, and who wrote them down

The figures at the centre of this story come from Meta's own internal posts, not from Reuters' analysis. An early June post by chief technology officer Andrew Bosworth reported code changes to internal platforms up 220% year over year. The same post put changes that led to new or upgraded user features up 36%.

Separate internal posts reported a 40% rise in major technical and security incidents, with examples such as service disruptions and possible data leaks. Staff time spent firefighting those incidents rose 70%. Meta declined to comment on that internal data.

Almost every article you will find on Project OT restates the same Reuters special report by Katie Paul, published on 26 August 2026. Dozens of aggregator posts repeat the 220%, 36% and 40% figures. That repetition is not corroboration. It is one source quoted many times.

No Meta filing, earnings call or public engineering blog has confirmed or contested the numbers. Treat every figure here as directional: real internal data, seen through one reporter's access, with definitions nobody outside Meta has checked.

Year-over-year multiples from Meta's internal posts Last year = 1.0. Bar length is proportional to the multiple. Code changes, internal3.20x Firefighting time1.70x Major incidents1.40x User-facing changes1.36x 1.0x line Source: Meta internal posts as reported by Reuters, 26 August 2026. Not independently verified.
Notice how close the bottom two bars are. Incidents grew at almost the same pace as shipped features, while internal code volume pulled far ahead of both.

Code output vs shipped features: reading the 220% and 36% gap

A 220% increase means the volume of code changes was 3.2 times last year's. A 36% increase means user-facing changes ran at 1.36 times. Divide one by the other and you get the ratio that matters: for every code change last year, Meta now produced about 0.43 user-facing changes for each unit of the old code volume. Put simply, user-facing output per code change fell by about 58%.

That is the number the internal posts were circulating around, even if nobody published it in that form. It is also the number most AI engineering productivity dashboards would never show, because they count the top line and stop.

Internal platforms are not the product

The 220% figure covers changes to the internal software platforms and infrastructure that Meta employees use on the job. That is tooling, build systems, internal services and the plumbing behind them. A large share of that work never becomes a feature a user sees, and it should not.

So part of the gap is definitional. Internal platform work can be valuable without ever touching the 36% line. My reading is that the comparison overstates waste, because it sets a broad internal measure against a narrow external one.

Why code volume is the wrong scoreboard

Code changes are the easiest AI output to count. Coding agents produce diffs quickly, and a diff counter rises with every one of them, whether it ships, gets reverted or sits in an internal tool nobody opens. A metric that rises automatically when you adopt a tool cannot tell you whether the tool worked.

This is not a Meta-specific failure. Google's DORA research team found in its 2024 report that, as AI adoption increased, there was an estimated 1.5% decrease in delivery throughput and a 7.2% reduction in delivery stability. Those are survey associations, not proof of harm. They point the same direction as Meta's internal data, and they came two years earlier.

The review queue is where the extra volume usually lands. When generation gets cheap, human review becomes the constraint, which is the mechanism covered in the analysis of code review as the AI bottleneck.

Meta's reported figures, recomputed per unit of work
RatioCalculationChange vs last yearWhat it suggests
User-facing changes per code change1.36 / 3.20About 58% lowerFar more code per shipped feature
Major incidents per code change1.40 / 3.20About 56% lowerIncidents did not scale with code volume
Major incidents per user-facing change1.40 / 1.36About 3% higherRoughly flat incident rate per shipped change
Firefighting time per incident1.70 / 1.40About 21% higherEach incident cost more staff time
Firefighting time per user-facing change1.70 / 1.36About 25% higherShipping a feature now carries more operational drag

Zan Digital calculation from the four year-over-year percentages reported by Reuters. It assumes all four figures share the same 12-month window and comparable definitions, which Reuters does not confirm. Ratios are rounded.

The 40% incident rise depends on the denominator you pick

The incident figure is the one that made headlines, and it is the one most easily misread. A 40% rise in major incidents sounds alarming on its own. Set against output, it reads very differently.

Per code change, incidents fell

If code changes rose 3.2 times and incidents rose 1.4 times, the incident rate per code change fell by about 56%. Someone defending Meta's AI push could cite that number with a straight face. It would be just as misleading as the headline, because most of the extra code never reached production users.

Per user-facing change, the incident rate rose by about 3%. That is close to flat. On this reading, Meta shipped 36% more user-facing changes and had 40% more major incidents, which is roughly what you would expect if failures scale with what ships. The table above shows all five ratios side by side.

Firefighting time is the number to take seriously

Staff time spent on incident response rose 70%, which is faster than incidents themselves. Each incident absorbed about 21% more staff time than a year earlier. That suggests the incidents got harder to diagnose or larger in scope, not merely more frequent.

There is a plausible mechanism for that, and I think it is the most interesting thing in the whole report. Code an engineer did not write is slower to debug than code they did, because nobody holds the reasoning behind it. That is a hypothesis, not a finding. It is also exactly what you would measure next if you ran engineering at Meta.

Same incidents, three different stories Index, last year = 100. Computed from Meta's internal figures as reported by Reuters. Incidents per code change44 Incidents per user-facing change103 Firefighting time per incident121 100 = last year Assumes the four reported figures share one 12-month window. Illustrative arithmetic, not Meta data.
Pick the first denominator and AI looks safer, pick the second and nothing changed. The third bar is the only one that moved meaningfully in the wrong direction.

Where the causal story about AI agents stops

Much of the coverage turned the Reuters findings into a simple claim: AI agents caused Meta's incidents, so Meta cancelled its layoffs. Neither half of that sentence is supported by the published reporting. Ars Technica's write-up of the Reuters report made the same point: the reporting does not identify the incidents or prove that agents caused them.

What the internal posts do say about agents

Reuters quoted an April internal post warning that unchecked AI agents were taking "large-scale, disruptive actions that humans are unlikely to execute". In March, infrastructure teams had already flagged reliability warning signs tied to the surge in AI-written code. Those are serious warnings from people close to the systems.

They are also qualitative. No published figure says how many of the major incidents involved an agent, an AI-written change or neither. An agent that deletes a large batch of records is a dramatic story. It is one data point, not a rate.

The confounders nobody has ruled out

Several things changed at Meta in the same 12 months. Roughly 8,000 people were laid off on 20 May, according to NPR's report on the internal memo, and Reuters reported that some engineering units shrank by as much as 30% by the end of May. Teams were reorganised into small pods. People moved into new priority areas.

Any of those could raise incident counts on its own. Fewer engineers who know a system, new owners on old services and reorganised on-call rotations all produce more and longer incidents. Nothing published says whether the comparison controlled for headcount, system size or reorganisation.

One incident Reuters described was hackers exploiting Meta's AI-powered customer support bot to reach high-profile Instagram accounts in early June. That is an AI failure, but it is a product security failure, not an internal coding failure. It belongs in a different bucket from the code-change data, and mixing the two makes the story tidier than it is.

What the Project OT figures can and cannot support
ClaimSupported by the reporting?Why
Code output grew much faster than shipped featuresYes, directionallyBoth figures come from the same internal post and period
Major incidents rose year over yearYes, directionallyInternal posts report it; definition and count not published
AI agents caused the rise in incidentsNoIncidents not itemised; no attribution to AI changes
AI made Meta's engineers less productiveNoNo per-engineer output measure; headcount fell in the same period
Incidents caused the cancelled second layoff roundNoReuters could not determine what prompted the decision

How the numbers fit the Meta AI layoffs timeline

The figures matter because of what they were used to argue. Project OT planned two waves of cuts: one in May and a second in November. On the night of 19 May, hours before the first wave, Zuckerberg called off planning for the second.

The temptation is to read the incident data as the reason. The dates do not allow it. Bosworth's post with the 220% and 36% figures went up in early June, after the second wave was already cancelled. Reuters stated directly that it was "unable to determine what exactly prompted Zuckerberg to shift course".

Reuters listed several pressures in play at the time: an employee revolt, internal data suggesting agents were not delivering the expected productivity gains, investor doubts about AI spending and the incident data. The company's half-year Pulse survey fell from 74% favourable to 55%. Any one of these could have been decisive. The honest answer is that we do not know which.

Project OT, January to August 2026 Dates as reported by Reuters and NPR. Red marks the decision; blue marks data. JanPlan drafted MarReliabilitywarnings AprAgent warningpost 19 MaySecond wavecancelled 20 MayAbout 8,000laid off Early Jun220% / 36%post Early JulTown hall 26 AugReutersreport The code and feature figures were posted after the cancellation, so they cannot have caused it.
Follow the order of the red and blue markers. The decision came first and the headline data came afterwards, which breaks the tidy cause-and-effect version of the story.

Zuckerberg's own public framing was patience, not reversal. At a July town hall he said agent technology had not "accelerated" as fast as he expected and that he expected benefits in "the next three to six months", according to Reuters. That is a delayed bet, not an abandoned one. If you want the wider pattern, the analysis of AI layoffs as an overhiring correction and the Cloudflare layoff evidence check test similar claims at other companies.

Where this reading is weakest

This post argues that the Project OT numbers support less than the headlines claimed. That argument has real weak points, and you should weigh them before you repeat it.

The ratios assume definitions nobody published

Every ratio in this post divides one reported percentage by another. That only works if the four figures cover the same 12 months and count comparable things. Reuters does not confirm either. If "major incident" was redefined during the year, or if the code-change count includes automated changes that were excluded before, the arithmetic falls apart.

The 58% decline in user-facing output per code change is therefore a reading of the reported figures, not a measured Meta statistic. I would not put it in a board deck without that caveat attached.

The case that AI really did cause the damage

The people inside Meta who wrote these posts had far more information than any outside reader. Infrastructure teams linked reliability warnings to the AI coding surge in March, before the layoffs. Engineers do not usually write warnings like that without seeing a pattern in incident reviews.

The firefighting figure also fits the AI explanation better than the headcount one. Fewer engineers would explain more incidents per person. It explains less well why each incident took 21% longer. Unfamiliar machine-written code is a plausible reason, and I would put real weight on it. Absence of published proof is not proof of absence.

What AI engineering productivity metrics should look like instead

The useful lesson from Meta is not about Meta. It is that a company with some of the best engineering telemetry in the world still ended up circulating a raw output count as evidence. If your dashboard leads with lines of code, pull requests merged or AI suggestions accepted, it has the same flaw.

A better scorecard puts outcomes in the numerator and output in the denominator. Shipped user-facing changes per engineer, incidents per shipped change and time-to-restore per incident all survive a tool that inflates code volume. The full framework is in the developer productivity scorecard for AI-assisted teams.

Track the cost side too. AI-generated code that ships but needs rework later shows up as maintenance load months after the dashboard celebrated it. The guide to AI code technical debt metrics covers which of those signals are measurable today. For agents acting on production systems, you also need runtime checks, which is the subject of the piece on monitoring agent drift in production.

My view is blunt: any AI rollout that cannot report incidents per shipped change before and after adoption has not been measured. It has been counted.

Frequently asked questions

What was Meta Project OT?

Project OT was an internal Meta plan, developed in January 2026, to make parts of the company AI native. Meta confirmed to Reuters it was a year-long project focused on cost cutting, redesigning team structures and moving staff into priority areas. Scenario planning explored shrinking some teams by up to 60%. Meta laid off about 10% of staff on 20 May and cancelled a planned second wave.

Did AI agents cause Meta's 40% rise in incidents?

The published reporting does not show that. Internal posts reported a 40% rise in major technical and security incidents and warned about agents taking disruptive actions. The incidents were not itemised, and nothing published says whether the comparison controlled for layoffs, reorganisation or system growth. Agents may have contributed, but causation has not been demonstrated publicly.

Why did Meta's code output rise 220% but features only 36%?

The 220% covers code changes to internal platforms and infrastructure, while the 36% covers changes that reached users. Part of the gap is definitional, because internal tooling work rarely becomes a user feature. The rest likely reflects AI tools generating far more code than reached production. Combined, user-facing changes per code change fell by roughly 58% on the reported figures.

Why did Meta cancel its second round of AI layoffs?

Reuters said it could not determine exactly what prompted Zuckerberg to change course on 19 May. Reported pressures included an employee revolt, internal data suggesting agents were not delivering expected productivity gains, investor doubts about AI spending and rising incidents. The code and feature figures were posted in early June, after the decision, so they could not have triggered it.

Is code output a good measure of AI engineering productivity?

No. Code volume rises automatically when teams adopt AI coding tools, whether or not the extra code ships or works. Better measures put outcomes first: user-facing changes shipped, incidents per shipped change and time to restore service. Meta's figures show the problem clearly, with code changes up 220% while user-facing changes rose 36%.

How reliable are the Meta Project OT figures?

They are directional. All four figures come from Meta internal posts reported by Reuters on 26 August 2026, and Meta declined to comment on the data. No filing or public Meta source confirms them, and definitions of incidents and changes were not published. Most other coverage restates the same Reuters report, so repetition across outlets is not independent confirmation.

Where to start this week

Open your engineering dashboard and find the metric your team celebrated most after adopting AI tools. If it counts output, such as pull requests, commits or accepted suggestions, rewrite it with shipped user-facing changes as the numerator.

Then pull last year's incident log and this year's, and divide each by the number of changes that reached production. One number before, one after. If you cannot produce both, that gap is the first thing to fix, and it is cheaper to fix now than after the next restructuring plan cites your dashboard.

Read next

The review queue is where AI code volume turns into delay. Read the analysis of code review as the AI bottleneck.

References

  1. Reuters, Katie Paul, Mark Zuckerberg had a bold plan to replace Meta staff with AI. Here's how it imploded, 26 August 2026. Read via the syndicated full text at TimesLIVE. Used for all internal Meta figures, dates, quotes and Meta statements.
  2. Ars Technica, Meta's scrapped plans to go AI native included slashing teams by 60 percent, August 2026. Used for the caveat that the reporting does not prove agents caused the incidents.
  3. NPR, John Ruwitch, Meta will lay off 10% of its staff, 23 April 2026. Used for the 20 May layoff of about 8,000 workers.
  4. Google Cloud, Nathen Harvey and Derek DeBellis, Highlights from the 10th DORA report, 23 October 2024. Used for the AI adoption association with throughput and stability.
  5. The Decoder, Maximilian Schreiner, Employee revolt and failing agents forced Meta to scrap its AI layoff plan, 26 August 2026. Secondary coverage, used to confirm the Pulse survey figures.

Weakest point of the source base: every Meta figure in this post traces to a single Reuters report of internal posts that Meta declined to discuss, with no published definitions. All ratios are Zan Digital calculations from those reported percentages. Last verified 11 November 2026.

SK
Sanskriti Khandelwal
Founding Member, Zan Digital. Writes about AI product economics, B2B software markets and what the numbers behind vendor claims actually say.

Related reading