For fifty years, the hardest part of software was writing it. That's no longer true.
AI coding assistants went mainstream — 90% of developers now use them (DORA 2025). Then came background agents: autonomous systems that take a ticket, write the code, run the tests, and open a pull request while the engineer sleeps. Stripe merges over 1,000 AI-written PRs per week. Ramp reached 30% AI-authored PRs within two months. Spotify has merged 1,500+ agent-generated PRs into production.
The cost of generating code is collapsing toward zero. But every line of AI-generated code still needs to be built, tested, verified, signed, deployed, and monitored. None of that got faster because code generation did.
The bottleneck shifted. And it shifted to exactly the problem Bitrise has spent a decade solving.
The false summit
Here's the trap I see teams falling into. They adopt Copilot or Claude Code. Engineers feel faster. PRs ship quicker. Leadership declares victory.
Then reality arrives. The CI queue backs up. Test suites that took 20 minutes now run constantly. Flaky tests that were merely annoying become paralyzing. The release train that shipped weekly can't handle daily. Build infrastructure sized for human-speed development buckles under AI-speed generation.
DORA calls this the amplification effect:
Agentic AI's primary role in organizations is that of an amplifier. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones.
Individual speed ≠ organizational velocity. Making each engineer faster doesn't matter if the system that turns their code into shipped software can't keep up.
What background agents actually need
Every company deploying background coding agents at production scale — Stripe, Ramp, Spotify, Cursor — independently built the same infrastructure:
- Isolated execution environments — agents can't fight over shared machine state
- Full toolchain pre-installed — agents shouldn't spend tokens installing Xcode
- Source code available — the whole point is working on the codebase
- Test execution integrated — agents must verify their own work
- CI/CD pipeline connected — code needs to actually ship
- Scalable to many concurrent sessions — one agent per task, many tasks in parallel
- Pre-warmed for fast start — cold starts kill agent economics
- Reproducible and deterministic — same environment every time, no drift
Every one of these companies built this from scratch. At enormous cost. With dedicated platform engineering teams.
Most engineering organizations cannot do this. And they shouldn't have to.
The Formula One car
I like to describe what we've built at Bitrise as a Formula One car for software engineering tasks. Not because any single component is the fastest — but because the integration is what wins races.
Bitrise is a vertically integrated platform where every layer shares the same foundation:
Build Infrastructure → We own and operate data centers in Amsterdam, Ashburn, and Chicago, running Apple Silicon (M2 Pro, M4, M4 Pro) and Linux hardware. This isn't cloud resale — it's owned infrastructure with structural cost advantages.
Stacks → Pre-built VM images with every tool a developer needs: Xcode (within 24 hours of Apple's release), Android SDK, build tools, simulators. Updated weekly. This eliminates the #1 time sink in both CI/CD and developer environment setup: fighting the toolchain.
Bitrise CI → Purpose-built mobile CI/CD with 400+ Steps, automated code signing, and self-healing builds.
Build Hub → GitHub Actions runner-as-a-service. Same Bitrise infrastructure, one line of YAML. Teams on GitHub Actions get M4 Pro hardware, pre-built stacks, and 30%+ faster builds without changing their workflows.
Build Cache → Fully managed remote caching for Bazel (83% reduction), Gradle (72%), and Xcode. CI-agnostic. Co-located with runners for zero-latency access.
Insights → Build observability: success rates, failure analysis, flaky test detection. The operational intelligence that tells you where your pipeline is breaking.
Release Management → From internal testing through App Store and Google Play submission. OTA distribution, phased rollouts, CodePush for React Native.
The critical insight: all of these run on the same infrastructure. The same VMs, the same stacks, the same datacenters. When we add Remote Dev Environments to this stack, a developer (or an agent) works in a cloud VM using the same stacks as CI. Push code, and CI runs on a sibling VM with an identical environment. The cache is shared. The release pipeline is connected. Environment parity is achieved by default, not by configuration.
Why mobile is the hardest problem — and the biggest opportunity
Mobile CI is a fundamentally different problem than web CI. macOS virtualization is a specialized discipline. Code signing is a domain-specific nightmare. Xcode builds are resource-intensive and slow. Device testing requires simulators and real hardware. App Store submission is a regulated, error-prone process.
Web development has mature cloud tooling — Codespaces, Ona, Replit. Mobile development has almost nothing. The AI coding revolution is reaching mobile teams last, and they have the least infrastructure ready for it.
In our recent customer interviews, this pattern was universal:
Our iOS developers are not benefiting as much from our AI tools as the rest of the company is today." — Staff Engineer, Fortune 500 fintech company
Our local machines can only do so much at one time... cloud VMs running Xcode builds in parallel — that's a pretty big bottleneck right now." — iOS Engineer, major social platform
"We can't build in a Zoom call because it just goes down to 50%." — Mobile Engineer, top consumer app company
Bitrise has been solving "mobile is the hard part" for a decade. The transition from "CI for mobile" to "the development platform where mobile is a first-class citizen" is a natural evolution — not a pivot.
Two types of intelligence, one infrastructure
Here's where I think the industry is heading. We're moving toward a world where both human developers (carbon-based intelligence) and AI agents (silicon-based intelligence) write code. They need the same thing:
- A reliable, pre-configured environment
- All the tools installed and maintained
- Source code available
- Tests they can run
- A pipeline that ships the result
The infrastructure doesn't need to care who's writing the code. It just needs to be reliable, fast, and integrated.
At Bitrise, we're extending our platform to serve both. Remote Dev Environments give humans interactive cloud VMs with the same stacks as CI — no more "works on my machine." The same environments serve AI agents: land in a pre-warmed VM, write code, run tests, push, and let CI verify. The boundary between human and agent development becomes fluid. The infrastructure is constant.
We've already demonstrated this working: Claude autonomously clones an iOS app, compiling it, running it in an iPad simulator, and verifying UI interactions — all within a Bitrise environment.
What this means for engineering teams
If you're already using AI coding tools: Your PR volume is about to multiply. Your CI/CD pipeline wasn't sized for this. Before it becomes a crisis, invest in the build/test/release infrastructure that will determine whether AI actually makes your organization faster — or just creates a bigger pile of unreleased code.
If you're evaluating background agents: The agent needs a full development environment. Not a sandbox, not a container with curl — a real VM with your toolchain, your source code, and your CI pipeline connected. Stripe built this in-house. Ramp built it in-house. You probably shouldn't have to.
If you're a mobile team: You're at the intersection of the hardest infrastructure problem (macOS, Xcode, code signing) and the fastest-moving industry shift (AI-generated code). The gap between what web teams have and what mobile teams have is about to become very expensive.
Bitrise was built for this moment. Not because we anticipated AI agents — but because we spent a decade solving the infrastructure problems that AI agents now face at scale. The same properties that make our build environments reliable for CI — reproducible, pre-tooled, scalable, secure — make them the ideal execution environment for whatever intelligence is writing the code.
The bottleneck shifted. We already solved it.
