AI Builds Surge 161×, but Mobile CI Pipelines Aren't Crashing
This article is an interpretation based on the Bitrise State of Mobile Development 2026 report. Some charts cannot be viewed directly in the public account; those who wish to see them can read the original article. Bitrise is a platform dedicated to mobile CI/CD.
Over the past two years, discussions about AI writing code have hardly ceased. On one side, there are cheers that "AI increases development efficiency tenfold"; on the other, warnings that "AI-generated code will crash your pipeline." Both sides have a point, but both lack one thing—data.
As a platform providing CI/CD pipelines for thousands of mobile development teams, Bitrise holds a vast amount of real build data. They analyzed over 19 million anonymous builds between Q1 2025 and Q1 2026 and produced this State of Mobile Development 2026 report. The core question is only one: What has AI-written code actually done to the mobile development pipeline?
The conclusion is somewhat unexpected.
161×: The Explosive Growth of AI Builds
This is the most explosive number in the entire report. In one year, the volume of builds tagged with AI markers grew 161 times. Note, this is not "AI tool usage increased by 161%," it is 161 times.
How does Bitrise determine if a build was generated by AI? They used three signals: a co-author line in the commit message (e.g., Co-authored-by: Claude), a known bot account triggering the build (e.g., webhook-github/cursor[bot]), or a branch name with an agent style (e.g., devin/1777625139-migrate-item-post).
# Three ways to identify AI builds
Co-authored-by: Claude <[email protected]>
webhook-github/cursor[bot]
devin/1777625139-migrate-item-post
This means the data in this report can only be more, not less. For example, a considerable number of people paste a piece of code from AI tools like Doubao and commit it under their own name; that build looks exactly like a normal commit. Taking myself as an example, when I use AI, the above situations basically never occur, so the actual volume of AI code is only higher.
Who Is Writing This Code: Claude Dominates
Looking at tool share, Claude accounts for 67% of AI builds, the undisputed leader. But two details are worth noting.
First, a declining share does not mean declining usage. The entire AI build pie grew massively during this hundredfold-plus growth, so while Devin and Copilot's shares shrank, their absolute build volumes are higher than before. It's just that Claude grew so fast it diluted everyone else's percentage.
Second, build share does not equal penetration rate. Copilot appears in more workspaces, but each workspace runs fewer builds, so its share is underestimated. In other words, Copilot is "used by many but runs little," while Claude is "used by perhaps fewer people but runs a lot."
Industry-Wide Adoption: From Travel to Insurance
A year ago, AI builds were near zero across all industries. Now, all 17 industries tracked by Bitrise show traces of AI builds. Travel leads, with 36% of workspaces having run at least one AI build; food delivery and consumer electronics follow closely, each at 35%.
At the bottom is insurance, at 13%. But think about it: the insurance industry inherently has higher requirements for code quality and compliance; 13% is already quite a lot. Moreover, none of these regulated, risk-heavy industries chose to sit on the sidelines—they are just more cautious, not absent.
The difference between industries is no longer "whether to use AI" but "how deeply." But this gap is rapidly narrowing.
The Biggest Surprise: AI Did Not Crash Builds
This is probably the most counter-intuitive part of the entire report. Before AI-written code entered pipelines at scale, many predicted that build failure rates would skyrocket. The reasoning was also sound—AI-generated code quality is unstable, lacks contextual understanding, and easily introduces compilation errors and logic bugs.
But the data provided by Bitrise tells a different story.
The failure rate for AI-related builds is 16.3%, actually lower than the 17.4% for non-AI builds. In terms of build speed, AI builds average 10.7 minutes, non-AI builds 11.8 minutes—AI builds are about 9% faster. The P90 slow tail is also shorter, 22 minutes vs. 24 minutes.
Some might think this is a bias caused by AI builds being concentrated in teams with better infrastructure. Bitrise thought of this too, so they did a second round of analysis: comparing AI and non-AI builds within the same workspace, the results were the same—AI builds still had lower failure rates and were about 5% faster.
An important caveat: This data is measured from the CI stage onwards, i.e., the situation after the code reaches the pipeline. What the developer did before pushing, how many rounds the agent ran locally—we cannot see. Moreover, it compares different builds, not the same pipeline triggered by a human versus an agent. So part of the gap may come from AI builds being different types of work. But the conclusion is clear: builds tagged with AI markers did not fail more.
Overall Failure Rate Remained Unchanged
Zooming out to the global view: the build volume for the same cohort of teams increased by 20%, but the overall failure rate slightly decreased from 17.8% to 17.4%. A failure rate of about one-sixth, exactly the same as before AI entered the pipeline.
Even more interesting is that the nature of failures is changing. Among classifiable failures, the proportion of "quality checks catching bugs" rose from 21.5% to 25.3%—tests and linting are doing their job. Meanwhile, true infrastructure failures remained stable at around 5.6%, unchanged.
Automation is also keeping pace. The usage frequency of Bitrise's automatic test rerun feature (used to automatically mark flaky tests) increased 5 times. For teams using Bitrise Test Reports, the single-test failure rate halved, while the test volume grew by 78%. This looks more like automation blocking problems on behalf of humans, rather than humans manually checking.
Build Times Dropped Instead of Rising: iOS Surpasses Android for the First Time
Build volume increased by 20%, but build times actually dropped. iOS builds decreased from about 13.7 minutes a year ago to 12.05 minutes, a 12% drop. Android dropped to 12.98 minutes. The two lines crossed in mid-2025—iOS builds became faster than Android for the first time.
The reasons fall into two layers.
On the hardware level, Bitrise's iOS fleet fully transitioned from the M1 era to M4. A year ago, 61% of iOS builds ran on M1 machines; now M1 accounts for only 4%, while M4 grew from zero to 54%. The sheer computing power improvement of M4 machines is directly reflected in build times. Even M2 machines of the same generation became 16% faster within a year.
On the software level, the Android team wasn't idle either. The adoption rate of Gradle Build Cache increased by 53% year-over-year, which made Android builds 7% faster. But Android's non-PR build failure rate dropped from 17.1% to 15.4%—the largest reliability improvement across all segmented data.
An Apple-related reminder: In the weeks following each major Xcode release, build failure rates can spike by up to 16 percentage points. Upgrading Xcode at Apple's pace is the most painful migration period. Pinning the Xcode version and upgrading at your own pace remains the easiest reliability gain in mobile CI.
What Truly Creates a Gap Is Not How Deeply AI Is Used, but Infrastructure
One comparison in the report left a deep impression on me:
80.6% of high-build-volume teams simultaneously enabled caching, test reports, and observability tools; only 6.6% of low-usage teams achieved this.
This gap is much larger than the gap between using more or less AI. Bitrise's data shows that at least 45% of active workspaces run automated tests in CI, but only 34% have test reports enabled. That means over one-tenth of teams are running tests but not even looking at the test results.
On modern infrastructure (Bitrise's current generation build stack), P90 queue wait times dropped by 13%, while build volume grew by 17%. But for teams still using old infrastructure, the extra load directly turned into queue buildup, with maximum wait times exceeding half an hour.
This has nothing to do with AI. The same infrastructure: good teams use M4 machines + caching + test reports + observability, resulting in fast builds, low failure rates, and short queues. Poor teams use old machines, no caching, no testing, no reporting, resulting in slow builds, many failures, and long queues. AI just pushes more code into the pipeline, but the quality of the pipeline itself determines whether this code can smoothly pass through.
My View
This report is not trying to tell you "how powerful AI is" or that "AI is a god." After all, over the past year or even two years, you have heard similar statements countless times. AI has undeniably changed mobile development, and this report is not discussing questions like "Can AI write Swift, Kotlin, or Flutter?" Its main value lies in this: the speed at which code enters the R&D pipeline is significantly increasing.
A few points that surprised me:
First, AI build failure rates are lower. This might not be because AI code quality is higher, but because AI tends to work in environments with sufficient context (mature workspaces, well-established pipelines), and AI tools may have already done local verification before pushing. But regardless of the reason, the prediction that "AI code will crash CI" does not hold up in the data.
Second, infrastructure is the watershed. The 80.6% vs. 6.6% comparison in the report is more informative than any AI tool market share comparison. If your team's builds are still running on old machines, without caching, and tests are not reporting, don't rush to switch AI tools—fix the pipeline first. AI will not save a terrible CI, but a good CI can make AI-written code flow more smoothly.
Third, automation is quietly doing the heavy lifting. A 5x increase in test reruns, single-test failure rates halved, test volume up 78%—these numbers are not in the spotlight, but they are the real reason the pipeline didn't collapse. Humans didn't get faster; automation did.
One final feeling: This report measures the CI stage. What happens before the code is pushed—how many rounds the AI agent ran locally, how many lines the human changed, whether tests passed locally—we still cannot see. The impact of AI on mobile development may be even greater than what this report can capture. But at least in this slice of the pipeline, the data says: the flood came, and the dam didn't break. Not because the flood wasn't fierce enough, but because the dam was quietly reinforced over the past year.
Original report: https://bitrise.io/reports/state-of-mobile-development-2026