Engineering leaders from Databricks, Google Maps, Ford, Uber and Instacart gathered on a panel at Android Dev Summit to compare notes on agentic coding, the practice of letting AI agents write, run and fix code with limited step-by-step human direction. Their shared verdict: code output has exploded, but the time it takes to put a feature in front of a user has moved far less, because the slow parts of software delivery were never the typing. The result is a concrete picture of how large organizations measure the gains, where the pipeline clogs, and how they are now putting limits on what the tools cost.

Output is up; outcomes are harder to prove

An engineering manager who directs AI tooling at Databricks said the company pushed more code in the past six months than in earlier, much longer periods. Pull request counts and lines of code have risen so fast that storage and repository management have become scaling problems in their own right. That volume, however, forced leadership to look for outcome metrics rather than celebrate raw numbers, and the industry still lacks a standard way to tie AI-generated code volume to business value.

The same leader described a persistent 5x to 10x productivity gap between outlier developers and the median engineer. Databricks has chosen to aim its AI initiatives at the median, raising the floor for the whole organization rather than making the fastest people faster.

A principal engineer on Uber's mobile developer platform offered the most striking number: individual developers working on greenfield projects, meaning new code with no legacy constraints, can produce up to 100 pull requests a day once fluent with current tools. Brownfield platform work, where a mistake can break critical infrastructure, still demands careful human judgment. Uber spent the past year studying whether faster coding actually speeds customer-facing feature delivery, and the early indicators are positive, though the question is not settled.

The firehose problem

A principal engineer at Instacart described what happens when one stage of a multi-stage pipeline suddenly runs many times faster: a firehose that overwhelms everything downstream. In the old model, a human engineer shepherded each change sequentially into production. Now agents flood pipelines that were sized for human pace.

A Google Maps engineering manager broke delivery into three phases: coding, production readiness (privacy and legal reviews, for example) and launch. Speeding up the first phase, in this framing, is like driving fast on a highway only to arrive sooner at the next choke point. Server-side services can ship continuously, but consumer apps need experiments, telemetry validation and staged rollouts before changes reach everyone.

Overhead view of a fast highway leading into a toll plaza with queued cars and then a narrow ramp into a store

▲ Three stages of delivery: coding, readiness, launch

The Uber engineer added a useful lens: agency. Internal tooling teams that control the entire lifecycle from idea to release ship dramatically faster with AI. Teams building external products must pass through design handoffs, product reviews and app store rollout schedules, which cap how much of the coding speedup survives to the end.

Ford's senior director of engineering, who leads vehicle subscription and customer loyalty platforms, made a point that reframes the whole debate: engineering was rarely the bottleneck even before AI. Upstream requirements and cross-functional debate consumed most of the calendar; once product and design settled, the implementation often amounted to adapting a known solution. Where Ford sees large velocity gains is in compliance and maintenance work such as upgrading Spring Boot versions. Timelines for conceiving genuinely new features have barely changed.

Where the gains concentrate

Type of work Observed effect of AI agents
Greenfield projects and internal tools Largest acceleration; up to 100 PRs per developer per day cited at Uber
Framework and dependency upgrades Major gains; Ford cites Spring Boot upgrades
Legacy platform code Limited; human judgment still required
New consumer-facing features Little change; bounded by specs, reviews and store rollouts

Rethinking code review as a verification problem

Since the slowest stage caps the whole organization's speed, and for most companies that stage is human code review, the central question becomes whether reviewing 100 percent of pull requests still makes sense.

The Databricks leader framed review as fundamentally a verification problem that can be re-engineered. Review serves two purposes: confirming correctness and educating the team about what is changing. One panelist estimated that roughly 70 percent of reviews today are superficial "looks good to me" approvals rather than real design scrutiny. Rather than pretend every review checks architectural patterns, organizations could train agents to recognize the characteristics that warrant routine approval and delegate those cases. The expectation offered was that a "very high double-digit percentage" of pull requests could eventually land without full human review, though never all of them.

The Instacart engineer proposed risk-tiered reviews: automated refactors and mechanical changes already covered by strong tests could skip mandatory peer review, while critical architectural paths keep it. He cautioned that when a bug could cost millions of dollars and draw CEO attention, human inspection remains indispensable. A tongue-in-cheek example captured the spectrum: refactoring an Android module in the Uber app is moderate risk; a bug that gives free rides to every Android developer needs CEO-level sign-off.

Several related ideas emerged:

  • Shift review from line-by-line syntax to verifying intent. As frontier models make fewer raw technical errors, the risk moves toward misreading business requirements or product intent.
  • Replace diff reading with visual artifacts, test outputs and before-and-after representations so reviewers judge behavior rather than syntax.
  • Treat review as "good friction." The goal is to reduce reviewer burden, not remove the safeguard.
  • Invest upstream. Detailed specifications and explicit architecture prompts yield markedly better generated code; vague inputs produce what one panelist called slop. Better inputs directly reduce review load downstream.

Why mobile is harder than backend

The tooling to land automated code safely already exists: feature flags, blue-green deployments, incident tracking and distributed tracing. The missing piece, according to one speaker, is that telemetry and observability data sit in disconnected silos. Synthesizing them into an integrated engineering context service is what would make confident auto-merging possible.

Mobile adds an asymmetric constraint. A backend team can hotfix or roll back in real time using internal observability. A mobile fix must pass Play Store review and then wait for users to update. That latency justifies more caution on mobile than on servers, and it explains why consumer app teams see smaller gains from agentic coding than their backend peers.

Infrastructure strain and the cost reckoning

Thousands of automated pull requests have real physical consequences. The Uber engineer said that continuous integration systems, which build and test every change, are under heavy load across developer platform teams, with frequent internal "Code Reds" triggered by compute spikes. Responses include Bazel remote build execution, distributed caching, self-healing CI pipelines and automated test triage.

One panelist urged teams to audit infrastructure against a 10x growth trajectory before an outage forces the issue. He relayed a quote from another company's CEO: Google took roughly 20 to 28 years to accumulate billions of lines of code, and AI acceleration will push ordinary companies to comparable scale in a few years, without Google-scale internal platforms to support it.

Developer watching a cost gauge while a router box sorts requests to small, medium and large machines beside a tripwire

▲ Model routing and spend tripwires

The cost story followed a clear arc. One engineering leader described the prior year as the year of experimentation, when engineers were encouraged to try AI on everything without financial constraint. In the first half of this year expectations shifted to reasonable use, and in September her organization formally enforced token limits, backed by instrumentation that tracks healthy session metrics and turns per interaction. The purpose is education: engineers need to internalize that an AI query costs real money. She drew a parallel to early AWS, when engineers spun up ECS instances needlessly and ran up cloud bills. The modern equivalent is spending $5 on a model call to switch a Git branch instead of typing a single command.

Another panelist argued these limits are healthy for architecture. Early on, engineers threw entire codebases at language models expecting magic; the bills prompted a rethink. He advocates deterministic generators for standard UI components and unit test boilerplate rather than live model inference. The Instacart engineer agreed that limits there aim at hygiene, not throttling: no one needs a frontier model to check the system time when a script does it for free, forever.

How the companies govern spend

Mechanism How it works
Cost visibility Teams see active session costs and model usage in their working environment
Token thresholds with one-click justification Developers who hit a standard limit send a request to their direct manager for more
Daily tripwires Soft limits that stop runaway overnight test or benchmark loops; engineers self-unblock in an internal portal with one click
Monthly frontier budget Generous allowance for cutting-edge models, with managerial exceptions above it
Model routers Programmatically map task types to appropriate model tiers so engineers stop choosing models manually

Two design principles stood out. First, limits are tripwires, not blockers: the point is to catch an automated loop that would otherwise accumulate thousands of dollars overnight, while keeping a human in the loop. Second, platform teams deliberately avoid being gatekeepers. Budget decisions stay with engineering managers who understand the business context. Panelists noted token prices are falling under competition among providers, but they consider developer stewardship necessary regardless, and they see automatic model routing as the long-term way to remove the burden from individuals.

One speaker contrasted the enterprise reality of paying per token with consumer tools sold on flat subscriptions, predicting that flat-rate models will eventually have to reckon with per-token economics. On Google's own internal token budget, the Google Maps manager offered only a caveat: a company that large has countless distinct sub-budgets, so no single answer applies.

Making time for AI readiness

Teams with large existing codebases rarely get a three-month pause to re-architect for AI. The advice was to treat AI readiness like technical debt: carve a recurring slice, for example 5 percent out of a typical 20 percent tech-debt allocation, for prompt refinement and context tuning. Many engineers still treat models as mystical black boxes and never configure prompts or supply enough context. Leadership, the panel argued, owns the job of upskilling teams so developers treat models as configurable engineering systems.

Training cannot be a one-time event. A single dedicated training week leaves a group far behind within a year because capabilities move so fast. Teams are "building the plane while flying it," adjusting guardrails as models improve, and in large enterprises platform teams act as distillation filters that turn a rapid stream of developments into usable internal guidelines.

What to take from this

The consistent message from five large engineering organizations is that agentic coding delivers real, measurable gains, but mostly in places where the whole lifecycle sits inside one team and the work is mechanical: internal tools, greenfield projects, framework upgrades and compliance chores. For user-facing products, the limiting factors are specification quality, review capacity, release pipelines and, on mobile, app store distribution.

For teams weighing adoption:

  1. Measure outcomes, not pull request counts, and target the median developer rather than the stars.
  2. Start agents on upgrades, migrations and internal tooling, where agency is high and risk is contained.
  3. Move toward risk-tiered review and intent verification, backed by strong tests, feature flags and unified observability, before loosening human gates.
  4. Stress-test CI and build infrastructure against a 10x increase in change volume.
  5. Put cost telemetry in front of developers, set tripwires rather than hard blocks, keep budget decisions with managers, and use deterministic scripts for anything repetitive.
  6. Budget a standing slice of engineering time for prompts, context and continuous learning instead of waiting for a dedicated modernization window.

None of this makes the tools less useful. It simply relocates the work: from writing code to specifying it well, verifying it efficiently and paying for it deliberately.