How Much Code Is Written by AI in 2026? The Real Numbers

TL;DR: Google says AI writes 75% of its new code. GitClear measures AI assistance in about a quarter of commits. Both are honest, because they count different things. The 2026 datasets agree on one thing: writing stopped being the constraint and review became it.

There is no single answer to how much code AI writes in 2026. The published figures run from about a quarter of commits to 75 percent of new code, and the spread comes from what each source counts rather than from anyone being wrong.

This guide sets the main numbers side by side, says what each one measures, and covers what the studies found once you look past the headline percentages.

How much code does AI write in 2026?

The honest answer is a range: between about 25 percent and 75 percent, depending on who is counting and what they count. Company self-reports sit at the top of that range and independent measurement sits at the bottom.

Figure	Source and date	What it counts
75% of new code	Sundar Pichai, Google Cloud Next, April 2026	New code that is AI-generated and approved by an engineer, company-wide, self-reported
64% of companies	Jellyfish benchmark, March 2026	Companies where a majority of code is generated with AI assistance, across 700+ firms
~25% of commits	GitClear and GitKraken, 2026	Commits with measurable AI assistance, from analysis of 623 million code changes
20% to 30% of code	Satya Nadella, LlamaCon, April 2025	Code in Microsoft repositories “written by software”, self-reported, not updated since
95% of the codebase	Garry Tan, Y Combinator, March 2025	About a quarter of one YC batch, at two to five person startups shipping a first product
90% of developers	DORA, 2025	Developers using AI at work at all, for a median of two hours a day

Every one of those numbers is defensible. Put next to each other without their definitions, they look like a contradiction.

Why Google says 75 percent and GitClear measures a quarter

The two figures answer different questions. Google is reporting the share of new lines that came out of a model and survived engineer approval. GitClear is reporting the share of commits where its analysis can detect AI authorship in the finished diff.

Three definitional gaps produce most of the spread:

• New code or all code. Pichai’s 75 percent covers new code only. A company’s existing codebase is untouched by that figure, and most engineering work happens inside code that already exists.
• Generated or surviving. A suggestion accepted into the editor is not the same as a line that reaches main. Rewriting an accepted block still counts as accepted in most telemetry.
• Self-reported or measured. Nadella and Pichai are describing internal telemetry nobody outside the company can audit. GitClear, DORA and Jellyfish, whose benchmark covers 700 companies and 20 million pull requests, publish their method and sample size.

Google’s own figure has moved fast on its own terms: more than a quarter of new code in October 2024, 50 percent in autumn 2025, 75 percent in April 2026. Microsoft has not published an update since Nadella gave 20 to 30 percent at LlamaCon in April 2025, so anyone quoting “30 percent at Microsoft” in late 2026 is quoting an 18-month-old number.

Does AI make developers faster?

Yes, but the gains shrink every time someone measures them instead of asking developers how they felt. The famous 55 percent figure comes from a 2022 GitHub study of 95 developers doing one task: build an HTTP server in JavaScript. That is close to the best case for a model.

METR ran a randomised controlled trial in July 2025 on the opposite case: 16 experienced open-source maintainers, 246 real issues in repositories they already knew well. Developers took 19 percent longer with AI tools available.

The perception gap is the part worth keeping. Those developers predicted AI would speed them up 24 percent beforehand, and still believed it had sped them up 20 percent after the measurement showed the opposite. METR is careful to call this a snapshot of early-2025 tools in one setting, not a general verdict.

Stanford’s software engineering productivity group reaches a compatible conclusion from a much larger sample. Yegor Denisov-Blanch’s team scores commits from roughly 100,000 developers at hundreds of companies, and reports a modest average lift through 2025 that depends on task type, codebase age and how common the language is, with an inflection in the data from December 2025.

Google’s DORA ROI report, published in 2026, cites Stanford figures of 35 to 40 percent gains on simple tasks against 10 percent or less on complex legacy code. It also models a J-curve: a temporary dip before the gains arrive, driven by a learning curve and what it calls the verification tax of reviewing more code.

The pattern across all four is consistent. Greenfield code, common languages and small well-specified tasks get large gains. Mature codebases and hard problems get little, and sometimes less than nothing.

Review is the bottleneck now

The clearest evidence for this arrived in July 2026, in a longitudinal study of a mid-sized company that mandated a doubling of merged pull requests per engineer from mid-2025.

Researchers tracked 802 developers and 196,212 pull requests from January 2024 to April 2026. Per-capita throughput hit 2.09 times the pre-mandate baseline, among the largest gains reported from a field deployment of AI coding tools.

The review numbers are the story. Load per reviewer roughly doubled, and automated review overtook human review. Merge and revert rates held steady, so the extra volume was not worse on those two measures. It was arriving faster than people could read it.

The paper title makes the point: AI writes faster than humans can review. Teams responding to that with AI code review tools are treating the symptom, but the accountability for what merges has not moved anywhere.

DORA’s 2025 findings point the same way from a different angle. AI adoption now correlates with higher delivery throughput, a reversal of the 2024 result, while still correlating with higher delivery instability. Teams ship more and break more.

Is AI-generated code good enough?

It compiles, it passes review, and it is harder to maintain. GitClear and GitKraken analysed 623 million code changes from 2023 to 2026 and found eight maintainability signals moving the wrong way at once.

Reported by LeadDev in July 2026, the headline movements are duplication up 81 percent, code reuse down 70 percent, legacy refactoring down 74 percent since 2023, cross-file connectivity down 35 percent, and error-masking constructs up 47 percent.

GitClear CEO Bill Harding put the mechanism this way: “Every time you want something, AI creates a new package for it.” Duplicating is cheap for a model. Finding the existing function and reusing it is not.

That is a debt curve rather than a bug count, which is why it stays invisible for a quarter or two. Teams already working on reducing technical debt are the ones who see it first.

Security has not improved either. Veracode’s 2026 GenAI Code Security Report tested more than 100 models on tasks with known vulnerability classes and found the average security pass rate sitting at 56 percent, and it has not moved.

Java came out worst at a 30 percent pass rate. Models built specifically for code averaged 51 percent against 52 percent for general-purpose models, so specialised training bought nothing. The best single model, GPT-5.5, reached 68 percent.

Volume is what changed, not the failure rate. Half-safe code at three times the output is three times the exposure, which is the argument for pairing generation with security scanning of AI tool output rather than trusting a review pass to catch it.

How developers actually use AI day to day

Adoption is near-universal and trust is not. The Stack Overflow Developer Survey 2025 found 84 percent of respondents using or planning to use AI tools, up from 76 percent, with 51 percent of professional developers using them daily.

Trust went the other way. Only 3.1 percent highly trust the accuracy of AI output, against 19.6 percent who highly distrust it, and 66 percent named “AI solutions that are almost right, but not quite” as their top frustration.

The task breakdown below is the share who say each job is currently mostly done by AI, so partial use runs far higher. It is still the clearest picture of where developers hand over and where they do not.

Task	Currently mostly AI	What that tells you
Search for answers	54.1%	AI replaced the search box first
Generating content or synthetic data	35.8%	Low stakes, easy to check
Learning new concepts	33.1%	Explanation is the strongest use case
Documenting code	30.8%	Nobody wanted to write it anyway
Learning about a codebase	20.8%	Growing fast as context windows grow
Debugging or fixing code	20.7%	Verifiable in seconds, so adoption is high
Testing code	17.9%	Patterned work, still supervised
Writing code	16.9%	Mostly still a collaboration, not a handover
Committing and reviewing code	10.2%	The judgment step stays human
Deployment and monitoring	6.2%	Highest blast radius, lowest delegation

Set that 16.9 percent against Google’s 75 percent and the gap is not a contradiction. Google measures lines that came out of a model. Developers are reporting who is in charge of the task.

Agent use is where the next jump sits. Only 14.1 percent of developers use AI agents daily, and 37.9 percent have no plans to, which is roughly where chat assistants were in 2023. Our round-up of AI coding agents covers what they can take on now.

Data engineering services can also support the underlying pipelines and infrastructure that ML teams rely on when developing and deploying these systems. Ingestion, transformation and orchestration code is far more patterned than a custom loss function, so it absorbs AI assistance faster than model code does.

What this changes about hiring engineers

The entry-level rung is thinning. Stanford’s Digital Economy Lab, working from ADP payroll records through June 2026, found employment for workers aged 22 to 25 in the most AI-exposed occupations running about 19 percent below where it would sit had it tracked their less-exposed peers.

The detail that matters for hiring plans is where those declines land: they concentrate in occupations where AI automates the task outright. In occupations where it complements the worker instead, employment is flat or rising.

Boilerplate, CRUD handlers and first-draft tests were the junior apprenticeship. That work is now the part models do best, which is what changed our own screening. Three things carry more weight than they did in 2023.

1. Review fluency. Reviewer load doubled in the one company we have longitudinal data for. An engineer who can read a 400-line generated diff and find the two lines that will page someone at 3am is worth more than one who can produce the diff.

2. System-level judgment. Models handle the contents of a file. Schema design, error boundaries, failure modes and the decision not to add a package are still where humans hold the pen.

3. Knowing when not to delegate. The METR and Stanford results both say the same thing: AI helps least on mature code and hard problems. Engineers who can call that boundary avoid the slowdown their peers report as a speed-up.

We test the first one directly now. Candidates walk through AI-generated code and say what they would keep, change or reject, which surfaces more in twenty minutes than a whiteboard exercise does in an hour. Our guide to becoming an AI-native engineer covers the same ground from the candidate’s side.

The cost side has not moved much. A senior engineer placed through Second Talent in the Philippines runs $3,000 to $6,000 a month, mid-level $2,000 to $3,000, junior $1,000 to $2,000. In a team where review is the constraint, two seniors clear more work than four mid-level engineers, and the rate card shows what each level costs across all nine markets.

Hire engineers who can review what the model writes

We place senior full-stack developers and AI and ML engineers across nine Asian markets, all of them shipping production code alongside AI tools. Placements go live in 5 to 10 days, with no retainer and no long-term lock-in.

Get matched with senior engineers in 24 hours →

Frequently asked questions

What percentage of code is written by AI in 2026?

There is no single figure. Google reports 75 percent of its new code as AI-generated and engineer-approved, while GitClear measures AI assistance in about a quarter of commits across 623 million changes. The difference comes from counting new code against all commits, and self-reported telemetry against independent measurement.

Does AI-generated code have more bugs?

Not measurably more defects at merge time, but worse maintainability. The 2026 GitClear analysis found duplication up 81 percent and refactoring down 74 percent since 2023, while the 2x mandate study found merge and revert rates holding steady as volume doubled. The cost shows up later, in code that is harder to change.

Is AI-generated code secure?

Roughly half the time. Veracode’s 2026 report puts the average security pass rate across more than 100 models at 56 percent, unchanged over the year, with Java worst at 30 percent. Model capability rose sharply in that period and security did not follow it.

Will AI replace software engineers?

It is replacing entry-level tasks rather than engineers. Stanford’s payroll analysis through June 2026 finds no widespread displacement, but a 19 percent employment gap for 22 to 25 year olds in the occupations where AI automates rather than assists. Demand moved up the seniority curve, not away from it.

How many developers use AI coding tools?

DORA’s 2025 report puts adoption at 90 percent of developers, a 14 point rise in a year, with a median of two hours a day spent working with AI. Stack Overflow’s 2025 survey found 84 percent using or planning to use the tools, and 51 percent of professional developers using them daily.

Do AI coding tools actually make developers faster?

On simple, self-contained work, yes. Stanford figures cited by DORA show 35 to 40 percent gains on simple tasks against 10 percent or less on complex legacy code, and METR’s randomised trial found experienced maintainers 19 percent slower on their own repositories. The gain depends on the task, not the tool.