The Pragmatic Engineer
By moving developers from synchronous pair programming to autonomous background agents, Uber successfully offloads high-volume toil and shortens the product delivery lifecycle.
AI-assisted summary of Uber: Leading engineering through an agentic shift - The Pragmatic Summit — original source. Check the original for full context.
Source published:
Key ideas
- Uber transitioned from synchronous IDE 'pair programming' to asynchronous 'peer programming,' with engineers acting as supervisors for long-running, multi-step autonomous agents. (3:36)
- The developer platform team now prioritizes toil automation as their highest strategic pillar, as 70% of early agentic requests focused on maintenance tasks like dependency updates and bug fixes. (6:41)
- Uber's internal AI developer tool spend has exploded by over 6x since 2024, necessitating a tiered model routing strategy to balance high-reasoning tasks with cost-efficient execution. (36:01)
- Success metrics have shifted from raw code volume to business outcomes, specifically measuring the compression of end-to-end cycle time from design to production feature delivery. (35:24)
Detailed notes
## Background Published on YouTube by The Pragmatic Engineer on March 10, 2026, this presentation from The Pragmatic Summit features Anshu Chada and Ty Smith from Uber's Developer Platform team. According to the video description, the session explores how Uber is leading its engineering organization through an agentic shift, supported by updated internal metrics showing widespread adoption of autonomous background coding and command-line agents.
## TL;DR Chada and Smith detail Uber's strategic evolution from synchronous tab-completion tools to asynchronous, multi-agent peer-programming workflows focused on eliminating maintenance toil. To enable autonomous agents securely within their private monorepos and microservice architecture, Uber engineered an internal platform suite including Minion for background execution, Code Inbox for triaging the resulting code explosion, U Review for noise-filtered code feedback, and Shepherd for large-scale migrations. Despite surging developer satisfaction and massive task automation, the team confronts real-world friction such as developer cultural inertia, legacy system debt, and a more than sixfold increase in AI compute expenses. To maintain enterprise viability, Uber employs tiered model routing to curb token burn and measures business success through end-to-end product delivery cycle times rather than raw code volume.
## Atmosphere & style The presentation carries a grounded, candid, and highly pragmatic tone, pairing Chada's executive-level organizational framing with Smith's detailed architectural walkthroughs. Rather than indulging in uncritical AI boosterism, the speakers speak transparently about friction points, from reviewers feeling overwhelmed by synthetic pull requests to facing intense CFO scrutiny over spiraling model costs. Watching the session feels like attending an insider retrospective on the messy reality of enterprise transformation, marked by practical problem-solving and an organizational willingness to let internal tools become obsolete as frontier models evolve.
## Bulletin - [03:36](https://www.youtube.com/watch?v=i1tZN41VKcE&t=216s) Uber transitioned from synchronous IDE 'pair programming' to asynchronous 'peer programming,' with engineers acting as supervisors for long-running, multi-step autonomous agents. - [06:41](https://www.youtube.com/watch?v=i1tZN41VKcE&t=401s) The developer platform team now prioritizes toil automation as their highest strategic pillar, as 70% of early agentic requests focused on maintenance tasks like dependency updates and bug fixes. - [36:01](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2161s) Uber's internal AI developer tool spend has exploded by over 6x since 2024, necessitating a tiered model routing strategy to balance high-reasoning tasks with cost-efficient execution. - [35:24](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2124s) Success metrics have shifted from raw code volume to business outcomes, specifically measuring the compression of end-to-end cycle time from design to production feature delivery.
## Key takeaways - [01:15](https://www.youtube.com/watch?v=i1tZN41VKcE&t=75s) AI has been promoted to one of Uber’s six core corporate strategic pillars, focused on 'superhuman' augmentation rather than developer headcount reduction. - [14:25](https://www.youtube.com/watch?v=i1tZN41VKcE&t=865s) The transition to agentic workflows relies on the 'Minion' background agent platform, which runs inside Uber's existing CI infrastructure to ensure secure, low-latency access to internal monorepos. - [09:36](https://www.youtube.com/watch?v=i1tZN41VKcE&t=576s) A cross-functional 'tiger team' was established to build a centralized, production-grade Model Context Protocol (MCP) gateway to govern enterprise-wide agent connectivity. - [10:15](https://www.youtube.com/watch?v=i1tZN41VKcE&t=615s) The AIFX CLI serves as the standard entry point for developers, ensuring consistent configuration management, prompt defaults, and secure MCP server discovery. - [19:48](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1188s) Code Inbox was created to mitigate the 'code explosion' risk, serving as a smart triage dashboard that filters noise and enforces review Service Level Objectives (SLOs). - [21:24](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1284s) U Review, an internal platform, uses a 'Review Grader' layer to filter out low-confidence AI comments and ensure only high-value feedback reaches developers. - [24:16](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1456s) AutoCover, using Uber's internal LangFX framework, generates roughly 5,000 unit tests per month with significantly higher quality than generic LLM-based test generators. - [25:46](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1546s) Shepherd is a dedicated campaign management tool that allows for fleet-wide code migrations by orchestrating multi-phase, scoped pull request generation. - [30:53](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1853s) The team prioritizes architectural abstraction over specific tools, allowing them to remain 'unmarried' to technologies as the rapid pace of AI evolution renders existing solutions obsolete. - [32:43](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1963s) Cultural adoption is driven by peer-to-peer evangelism; grassroots promotion by influential engineers is significantly more effective than top-down executive mandates. - [36:01](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2161s) Tiered model routing is the primary defense against spiraling AI costs, assigning high-cost frontier models only to complex architectural tasks. - [24:48](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1488s) The shift to AI-generated code necessitates an increased focus on rigorous unit test validation via an adversarial 'Critic Engine' to prevent brittle test mocks.
## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=i1tZN41VKcE&t=4s) Introduction and the ROI-Driven Agenda
Anshu Chada opens the session by welcoming the audience and introducing the presentation team from Uber's Developer Platform organization. Chada leads Developer Platform at Uber, while co-speaker Ty Smith is a principal engineer who has served as one of the primary engineering voices steering both Uber's recent agentic shift and its broader, multi-year artificial intelligence strategy. Eager to leave ample time for audience questions and debate at the end, Chada outlines a packed, three-part agenda designed to showcase both technical breakthroughs and bottom-line impact:
1. The core motivations driving Uber’s aggressive pivot toward agentic AI, alongside the tangible return on investment (ROI) that the engineering organization has already captured. 2. A technical deep dive led by Ty Smith into the specific platforms, systems, and integrations that unlocked these productivity gains. 3. A concluding exploration of the non-technical frictions encountered along the way, ranging from culture, org design, and developer mindsets to measurement frameworks and escalating cloud costs.
Chada emphasizes that this initiative is not speculative experimentation, remarking: “We're going to walk through what has motivated our push into agentic AI and some of the key ROI that we we've we've manifested.” He underscores the business reality behind their effort by adding, “And there is key ROI.”
---
[01:15](https://www.youtube.com/watch?v=i1tZN41VKcE&t=75s) Uber's Strategic AI Shift: Superhumans, Not Replacements
Machine learning and artificial intelligence are foundational to Uber's core business; proprietary AI models have powered the company’s marketplace matching and dynamic fares platforms for years, providing its defining competitive edge. What is fundamentally new over the past few years, however, is embedding AI directly into the internal software development lifecycle and developer productivity tooling. This internal adoption has elevated AI from a localized tool into one of six overarching corporate strategic pillars established by Uber CEO Dara Khosrowshahi. While the company initially termed this transition a migration from a human-and-early-AI company to a "generative AI-powered" enterprise, Chada quips that the label has already become passé in favor of becoming an "agentic-powered company."
Crucially, the leadership team explicitly rejects the narrative that AI exists to replace the human engineering workforce. Framing the executive vision, Chada references Khosrowshahi's stance: “Dara made this quote, which is, you know, AI AI is enabling people to become superhumans um in terms of their productivity and the impact that we can realize for our end users.” The goal is radical augmentation: using generative and agentic tools to eliminate repetitive engineering drudgery—such as library upgrades, technical migrations, and routine bug fixing—so engineers can dedicate their cognitive energy to creative problem-solving and rapid product feature delivery.
- AI has driven Uber’s external algorithmic core (fares and driver-rider matching) for nearly a decade. - CEO Dara Khosrowshahi designated AI adoption as one of Uber’s six company-wide strategic shifts. - Internal AI efforts focus squarely on offloading toil rather than reducing developer headcount.
---
[03:35](https://www.youtube.com/watch?v=i1tZN41VKcE&t=215s) From Pair Programming to Peer Programming
Reflecting on the evolution of developer tooling, Chada contrasts the early days of generative coding in 2022 and 2023 with the present paradigm. The introduction of tools like GitHub Copilot established the era of "pair programming," defined by synchronous inline tab-completions and in-IDE chat sidebars. While Uber’s internal tracking showed a respectable 10% to 15% bump in overall developer velocity from synchronous pair programming, it was ultimately an incremental optimization of traditional software workflows.
The true inflection point arrived over the past year with the transition to asynchronous "peer programming." Backed by advanced frontier models capable of sustained multi-step reasoning over hours rather than sub-second completions, engineers can now delegate end-to-end tasks to autonomous agents and step back into supervisory roles. Chada highlights this structural evolution in how software engineers operate: “And that's that's all culminated in this model where we imagine developers acting as their own tech leads.” Developers formulate intent, hand off long-running maintenance workloads—such as dead code elimination, documentation generation, and complex dependency updates—and provide high-level course corrections only when an agent requests review. Once dismissed as a social media punchline, "vibe coding" has matured into a viable enterprise workflow adopted across high-performing tech companies like Ramp and Anthropic.
```mermaid flowchart LR accTitle: Evolution of AI-Assisted Engineering accDescr: Diagram illustrating the shift from synchronous pair programming to asynchronous agentic peer programming.
subgraph Pair["Pair Programming (2022-2023)"] direction TB P1["Synchronous Tab-Completion"] P2["IDE Chat Sidebars"] P3["10-15% Velocity Bump"] P1 --> P2 --> P3 end
subgraph Peer["Peer Programming (Present)"] direction TB A1["Asynchronous Agent Hand-off"] A2["Developer as Tech Lead"] A3["Autonomous Execution (Hours)"] A1 --> A2 --> A3 end
Pair -->|"Paradigm Shift"| Peer ```
---
[06:41](https://www.youtube.com/watch?v=i1tZN41VKcE&t=401s) Toil Automation and the Virtuous Adoption Cycle
When Uber's Developer Platform team first rolled out autonomous agentic capabilities to the engineering organization, developers organically gravitated toward maintenance rather than net-new feature creation. Chada reveals that 70% of the initial workloads submitted to the platform were categorized as engineering toil. This behavioral pattern was driven by structural task characteristics: maintenance tasks like dependency upgrades, deprecations, and library migrations feature unambiguous start and end states, clear compiler feedback, and deterministic validation criteria, whereas greenfield features demand business context, UI experimentation, and complex product trade-offs.
Because these bounded toil tasks yielded substantially higher task accuracy and completion rates, developer trust surged rapidly. Chada describes how this dynamic unlocked self-reinforcing adoption across the company: “As soon as we made our agentic workflows available to developers, what we saw is 70% of the workflows that developers are pushing into the system were toil tasks.” High accuracy encouraged engineers to feed increasingly complex maintenance pipelines into the agentic system, sparking a virtuous cycle that led Chada’s Developer Platform leadership team to establish toil automation as their single highest strategic priority for internal AI tooling.
- 70% of all early agentic requests submitted by Uber engineers were toil-oriented workloads. - Bounded maintenance tasks (e.g., framework updates, dead code removal) exhibited significantly higher completion accuracy than open-ended product work. - Proven success in toil reduction drove organizational buy-in and made autonomous workflows a top platform priority.
---
[07:41](https://www.youtube.com/watch?v=i1tZN41VKcE&t=461s) Uber's Agentic Architecture: Standing on the Shoulders of Michelangelo
Handing over the presentation to Ty Smith, the discussion transitions from strategic motivation to system architecture. Smith emphasizes that Uber’s modern agentic ecosystem was not invented in a vacuum or assembled overnight. Instead, the platform team explicitly designed its agentic infrastructure on top of nearly a decade of mature machine learning investments: “And so we really see ourselves as building on the shoulders of giants.”
```mermaid flowchart TD accTitle: Uber Agentic Platform Architecture accDescr: Layered architectural diagram showing how Uber builds agentic workflows on top of Michelangelo, organizational context, and specialized agent runtimes.
subgraph Enablement["Governance & Enablement"] E1["Cost Control & Measurements"] E2["Developer Education & Guardrails"] end
subgraph Agents["Agent Execution Layer"] A1["Minion Background Agent Platform"] A2["Automated Test Generation"] A3["Industry Clients (IDE / CLI)"] end
subgraph Context["Organizational Memory & Context"] C1["Source Code & Repositories"] C2["Internal Docs, Jira & Slack"] C3["Central MCP Gateway"] end
subgraph Foundation["Michelangelo ML Foundation"] M1["Model Gateway (OpenAI, Anthropic Proxies)"] M2["Internal Model Hosting & Inference"] end
Foundation --> Context Context --> Agents Agents --> Enablement ```
At the foundation sits Michelangelo, Uber’s historic machine learning platform. Historically utilized for model training and feature stores, Michelangelo was modernized to include a unified Model Gateway. This gateway securely proxies requests to leading external frontier model providers (including OpenAI and Anthropic) while managing access to proprietary internal models.
Directly above the model gateway lies the contextual infrastructure that provides agents with institutional memory. To operate with human-level efficacy, agents must ingest internal source code, architecture documentation, Jira tickets, and active Slack discussions. Above this contextual tier, the team supports both external industry clients (such as IDE-based tooling and CLI agents) and purpose-built internal platforms, such as Minion (Uber’s asynchronous background agent runtime) and specialized test generation pipelines. The entire stack is capped by an engineering enablement layer focused on cost attribution, observability, and education.
---
[09:36](https://www.youtube.com/watch?v=i1tZN41VKcE&t=576s) The Cross-Functional Tiger Team and Central MCP Gateway
As the Model Context Protocol (MCP) gained widespread industry traction, Uber recognized it as a powerful mechanism to connect autonomous agents with company-wide services and data repositories. Rather than permitting fragmented, unvetted MCP integrations across individual engineering groups, platform leadership moved decisively to centralize infrastructure, security, and access control.
Smith explains that the company formed an elite, cross-functional "tiger team" drawn from infrastructure, platform, and security organizations across Uber. Their mission was to architect a unified enterprise MCP strategy and build a production-grade Central MCP Gateway. Smith explains their rapid mobilization: “This became a very popular piece of technology in the industry last year, and we moved very quickly to make sure that this was deployed and secure for our engineers so that we could make them as productive as possible.” The resulting gateway acts as an authenticated, auditable proxy between agent clients and underlying service infrastructure, standardizing authorization and governance across all internal and external MCP servers.
[10:15](https://www.youtube.com/watch?v=i1tZN41VKcE&t=615s) Platformizing Agent Tooling: Michelangelo, MCPs, and the AIFX CLI
To make agentic development scalable across thousands of engineers, Uber recognized early on that ad-hoc local configurations would quickly devolve into chaos. The developer platform team set up an infrastructure ecosystem anchored by a central Model Context Protocol (MCP) registry and sandbox. This sandbox gives engineers a safe playground where they can discover new MCP servers, test them against internal systems, and verify their behavior with comprehensive telemetry and logging before using them in workflows. Concurrently, Uber leveraged Michelangelo—its proprietary internal machine learning platform—to provide both code SDKs and no-code agent builders. Equipped with visualization, telemetry, and distributed tracing, these tooling foundations enable any team across the company to build custom agents that tap securely into internal services and proprietary datasets, while publishing them back to a shared registry for cross-company discovery and reuse.
Crucially, these agents needed to run uniformly across multiple environments, including Uber's DevPod remote development infrastructure, local developer laptops, background execution runners, and production services. Because engineers rely on a diverse and shifting set of clients—ranging from Claude Code and Codex to Cursor—Uber created a unified command-line entry point called the AIFX CLI. As Ty Smith explained: “One thing that we recognized we needed to platformize pretty quickly was a central ability to provision and configure and update the clients, the agent clients themselves, the ability to install and discover MCPs from the registry, configure those inside of the agent clients, deploy standard configuration management so that people who are just new to the space are having more effective prompts and configurations right away.”
```mermaid flowchart TD accTitle: Uber Agent Platform Architecture accDescr: Diagram showing how AIFX CLI bridges registries to developer clients and runtime environments.
subgraph Registries ["Central Registries & Builders"] R1["MCP Registry & Sandbox"] R2["Michelangelo Agent Builder<br/>(SDKs & No-Code)"] end
subgraph PlatformLayer ["Management Layer"] CLI["AIFX CLI<br/>(Client config, updates, prompt defaults)"] end
subgraph Clients ["Developer Clients"] C1["Claude Code"] C2["Cursor"] C3["Codex"] end
subgraph Runtimes ["Execution Environments"] E1["DevPod (Remote Dev)"] E2["Local Laptops"] E3["Minion Background Agents"] E4["Production Services"] end
Registries --> CLI CLI --> Clients Clients --> Runtimes ```
- **Michelangelo Agent Platform:** Supports both SDK-driven and no-code creation of internal agents with built-in tracing, telemetry, and access to internal microservices and datasets. - **AIFX CLI:** Serves as the developer-facing gateway to ensure baseline system prompts, approved client versions, and standardized MCP server connections across the engineering organization. - **Universal Environments:** Ensures consistent execution behavior whether an agent is executed inside an engineer's remote DevPod instance or deployed into background infrastructure.
---
[12:25](https://www.youtube.com/watch?v=i1tZN41VKcE&t=745s) The Multi-Agent Shift and Why Third-Party Infra Didn't Fit
The arrival of agentic systems has fundamentally disrupted the historic developer loop. In traditional software engineering, developers spent a modest fraction of their schedule planning, committed the bulk of their time to hands-on code authorship, and dedicated a smaller slice to peer review, cycling through a tight edit-build-run-verify cycle inside standard IDEs. The initial wave of AI integration altered this slightly by introducing interactive in-IDE chat or terminal agents (like Cursor or early Claude Code sessions) where the developer continually watched outputs, approved terminal execution steps, and steered the model command by command.
However, developer behavior at Uber quickly advanced to an asynchronous, multi-agent paradigm where engineers fire off long-running tasks autonomously in the background. Ty Smith highlighted the psychological shift driving this pattern: “This gets into this place where as an engineer you're giving a prompt, you're waiting for some time while it's running. You're thinking, 'Oh, what am I going to do? Am I going to go have a coffee or browse Reddit? Might as well kick off another background agent.' And so they get into this mode of the new flow looks like running several agents at once.”
While external commercial vendors were beginning to offer their own background agents, they almost universally hosted compute on their own third-party cloud infrastructure. Handing over enterprise background execution to external environments presented immediate security and operational hurdles for Uber, as their workloads required direct, low-latency access to massive internal monorepos, private networks, and internal microservices. Ty Smith noted that while third-party hosting might evolve over time, “having the ability to bootstrap on our own infrastructure was really important to us and allowed us to move really quickly.”
- **Workflow Divergence:** The traditional edit-build-test loop has been superseded by an asynchronous model where developers orchestrate and supervise multiple parallel background jobs. - **Infrastructure Sovereignty:** Running background agents on vendor-hosted runners introduces isolation from enterprise monorepos and internal network perimeters, prompting Uber to build in-house execution runners.
---
[14:25](https://www.youtube.com/watch?v=i1tZN41VKcE&t=865s) Minion in Action: Uber’s Autonomous Background Agent Platform
To run background agents entirely within their security perimeter, Uber built Minion, an autonomous background agent execution platform. Minion integrates directly with state-of-the-art agent CLIs and SDKs while running on top of Uber's existing continuous integration (CI) platform. Because it operates natively inside Uber's CI cluster, Minion tasks spin up with the target monorepos already checked out, full network access to internal microservices pre-authenticated, and connections to internal MCP servers configured via AIFX. Minion surfaces across multiple interfaces: a dedicated web UI, Slack notifications and commands, GitHub pull request comments, the AIFX CLI, and programmatic APIs that other internal services can invoke.
Walking through an actual production use case, Ty Smith demonstrated how an engineer resolved an unexpected crash. A user had reported an error message encountered while running a command on macOS. Rather than switching contexts, checking out branches, and reproducing the bug locally, Smith pasted the raw command, operating system details, and error output directly into the Minion web dashboard. The Minion interface provides curated prompt templates with parameter placeholders, lets the author target specific monorepos or pull requests, and allows selecting the underlying driver agent (such as Claude Code). Because Uber has been in a multi-year migration from Phabricator to GitHub, Minion seamlessly supports outputting code changes as either a Phabricator Differential diff or a GitHub pull request.
The system also includes a built-in prompt improver. When Smith entered his raw report, the interface flagged a red indicator signaling that the prompt quality was sub-optimal and carried a lower probability of success; clicking the improver analyzed the text and suggested automated additions that Smith accepted. Once launched, Minion pinged the author via Slack with a task tracking link. Exactly seven minutes later, a follow-up Slack message confirmed the job was complete. The dashboard provided full inspection logs and retry options, but in this case, Minion had already opened a clean GitHub pull request co-authored by the Minion bot and Smith, populated with a linked Jira ticket and an explicit test verification plan.
```mermaid flowchart LR accTitle: Minion Task Execution Flow accDescr: End-to-end flow from developer prompt entry in Minion web UI to an opened GitHub pull request.
subgraph Input ["Task Creation"] A["Developer Prompt<br/>(Error + Environment)"] --> B["Prompt Improver<br/>(Quality Analysis)"] B --> C["Select Target Repo &<br/>Driver (Claude Code)"] end
subgraph Execution ["Minion Platform (CI)"] C --> D["Uber CI Runner<br/>(Monorepo + MCPs)"] D --> E["Autonomous Fix &<br/>Verification Run"] end
subgraph Output ["Completion & Notification"] E --> F["Slack Ping<br/>(7 min elapsed)"] E --> G["Generated Pull Request<br/>(Co-authored + Jira + Tests)"] end ```
- **Monorepo Readiness:** Minion avoids slow environment provisioning by running directly on CI compute nodes where monorepo caches and network routes already exist. - **Prompt Quality Guardrails:** An automated prompt evaluator flags under-specified instructions with a visual warning and offers an inline prompt rewriting engine to maximize task completion rates. - **Seven-Minute Turnaround:** In the demonstrated real-world bug fix, Minion understood the Mac-specific crash, implemented the fix, verified tests, and produced a review-ready PR with Jira metadata in seven minutes.
---
[18:41](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1121s) Code Explosion and Tackling Context Switching with Code Inbox
The proliferation of autonomous agents has flipped the traditional engineering bottleneck on its head. Because agents can generate code orders of magnitude faster than humans can write it, developers are spending an unprecedented percentage of their working hours planning prompts and performing code reviews. Ty Smith highlighted the cultural friction this causes across teams: “They're spending more and more time in planning and code review because there's so much more code being generated that they're being forced to do it. This probably isn't the favorite type of work the developers love doing, code review.”
This code explosion carries severe operational risks. When developers face dozens of pull requests waiting for review, cognitive fatigue sets in. Review turnaround times slow down, and worse, reviewers risk rubber-stamping diffs and letting critical bugs slip through into production simply because the sheer volume of code overwhelms human attention. Furthermore, managing dozens of asynchronous tasks across Minion, GitHub, and local environments introduces crippling context-switching overhead whenever an agent requires intervention or finishes a run.
To tame this distraction stream, Uber's developer platform team developed Code Inbox, a specialized application acting as a unified triage dashboard for pending code reviews. Rather than inundating an engineer with raw chronological GitHub notifications and Slack pings, Code Inbox filters out passive noise and surfaces strictly actionable items. A pull request or agent execution only appears in the engineer’s queue when it actively demands their input or decision, keeping engineers focused on unblocking their teammates and agents without drowning in automated notifications.
- **Review Burden Shift:** The primary time sink for developers has inverted from writing code to reviewing massive volumes of synthetic, AI-generated pull requests. - **Code Inbox Triage:** Centralizes incoming pull requests across systems into a filtered feed, hiding PRs that are stalled or waiting on others and elevating only those requiring immediate human intervention.
[19:48](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1188s) Code Inbox: Smart Reviewer Assignments, Noise Control, and Blast Radius Analysis
To streamline the human side of code review, Uber invested heavily in "Code Inbox," an intelligent routing and notification engine designed to pair pull requests with the right reviewers without spamming engineers. Rather than relying on static code owners files, the system analyzes compliance boundaries, working history, and real-time developer context such as time zones and calendar availability. Once assigned, Code Inbox monitors progress against strict Service Level Objectives (SLOs), providing visibility into pending reviews and automatically triggering reassignments or leadership escalations when reviews stall.
Notification delivery is deeply tuned to developer psychology and daily schedules. The platform batches notifications to prevent notification fatigue and coordinates with Slack to respect calendar focus blocks, holidays, and out-of-office statuses. For organizations that already rely on team-level Slack review channels or triage queues, Code Inbox injects incoming reviews directly into those workflows. In parallel, the platform estimates the risk profile of each incoming patch by evaluating its blast radius, total surface area, and whether it touches a lightweight test or a core production service. These risk insights are surfaced upfront so developers know when a change warrants heightened scrutiny or an extra reviewer.
- Analyzes code ownership, compliance rules, historical contributions, time zones, and calendar availability to assign reviewers. - Enforces strict review SLOs with automated escalation and reassignment for stalled PRs. - Batches Slack notifications and halts alerts during developer focus time and scheduled time off. - Plugs directly into existing team-level Slack code review queues. - Computes blast-radius estimates and service criticality to flag high-risk changes directly to reviewers.
---
[21:24](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1284s) U Review: An In-House Graded AI Code Review Pipeline
Addressing the actual content of code reviews led Uber to build U Review, an internal platform tailored to provide intelligent, contextual feedback on incoming changes. While Ty Smith acknowledged the proliferation of commercial review tools like CodeRabbit and Graphite—noting that Uber frequently tests and integrates external offerings—he emphasized that Uber's internal complexity and its ongoing migration from Phabricator to GitHub necessitated a unified, proprietary platform. U Review acts as a controlled gateway that runs a preprocessor over code diffs, orchestrating a suite of plugins that include internal defect bots, best practice checkers, Model Context Protocol (MCP) servers, and third-party tools via an open API.
```mermaid flowchart LR accTitle: U Review AI Code Review Pipeline accDescr: Pipeline showing code changes flowing through preprocessing, grading, deduplication, and dual-UI rendering.
subgraph Ingestion["Input & Analysis"] Diff["Code Change"] --> Prep["Preprocessor & Plugins"] Prep --- Bots["Defect Bots & MCPs"] Prep --- Ext["External Review Bots"] end
subgraph Quality["Filtering & Evaluation"] Prep --> Grader["Review Grader"] Grader --> Dedupe["Deduplication & Categorization"] end
subgraph Delivery["Surfacing to Developer"] Dedupe --> UI["Dual UI Layer"] UI --- Phab["Phabricator UI"] UI --- GH["GitHub PRs"] end ```
The core breakthrough in U Review is its dedicated "Review Grader" layer. Ty Smith pointed out that off-the-shelf bots often generate low-value noise and pedantic nits just to surface feedback. U Review runs specialized evaluation models at each layer of the pipeline to measure model performance against specific tasks, ensuring that only high-confidence, actionable comments reach the author. Over the past year of iteration, the platform saw an increase in the volume of best-practice suggestions while simultaneously sustaining a high resolution rate from engineers, validating that the comments are genuinely helpful rather than annoying. Because Uber operates across two code review ecosystems during its transition, U Review powers custom interfaces in both GitHub and Phabricator with built-in feedback loops. As Ty Smith explained when discussing why aggressive filtering is essential:
> “And we really only want to put the high confidence changes that the developer really needs to focus on, not little nits.”
- Combines internal defect bots, architectural best practices, MCP integrations, and external vendor bots through a single API. - Implements a Review Grader stage to eliminate low-confidence comments, style nits, and duplicates. - Uses distinct, benchmarked LLM models optimized for each stage of evaluation and categorization. - Tracks comment resolution rates as a primary success metric to ensure developers fix flagged issues rather than dismissing them as spam. - Features dual-UI compatibility supporting both legacy Phabricator diffs and modern GitHub pull requests.
---
[24:12](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1452s) AutoCover and the Critic Engine: Scalable, High-Quality Unit Test Generation
As AI dramatically accelerates the volume of incoming code, maintaining rigorous CI verification and automated testing becomes critical to prevent subtle defects from slipping through review. To solve this, Uber created AutoCover, a specialized unit test generation system built by an engineer whom Ty Smith spotted in the summit audience. While generic coding assistants and command-line tools can write test boilerplate, Uber discovered that building a domain-specific agent atop LangFX—Uber's internal LLM framework built on LangChain—produced test suites of substantially higher engineering quality.
AutoCover generates and merges roughly 5,000 unit tests every month across Uber's repositories, achieving nearly triple the quality rate of generic LLM agents. To protect against the hazard of brittle "change detector" tests and false confidence from inflated line coverage, the team incorporated an adversarial "Critic Engine." This module evaluates whether generated tests genuinely verify business logic or merely mirror implementation details. Uber subsequently decoupled the Critic Engine into a standalone "Test Validator" tool, enabling developers to run automated quality grading against both human-written and AI-generated tests across the company.
- Generates and successfully merges approximately 5,000 automated unit tests per month across Uber. - Outperforms off-the-shelf LLM coding tools by nearly 3x in test quality by leveraging Uber's internal LangFX framework. - Incorporates a Critic Engine to catch change-detector tests, superficial assertions, and brittle test mocks. - Offers the Critic Engine as an independent Test Validator for grading human-written and AI-authored tests alike.
---
[25:46](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1546s) Auto Migrate and Shepherd: Managing Large-Scale Code Migrations at Scale
Transitioning to code maintenance and toil reduction, Ty Smith reflected on the industry narrative surrounding AI-generated code. Hearing tech executives announce to news outlets and shareholders that massive percentages of their codebases were now AI-authored prompted Uber's platform team to investigate how engineering organizations like Google and Meta achieved those milestones. They realized those companies had previously built foundational infrastructure for Large-Scale Changes (LSCs), creating a structural prerequisite that generative AI could amplify. Lacking that foundational automation, Uber launched a major cross-functional program called "Auto Migrate" to industrialize codebase-wide modifications across four stages: problem identification, code transformation, automated validation, and campaign management.
```mermaid flowchart TD accTitle: Auto Migrate Four-Stage Architecture accDescr: The four key phases of Uber's Auto Migrate platform powered by Shepherd.
P1["1. Problem Identification"] -->|"Slice PRs & assess risk"| P2["2. Code Transformation"] P2 -->|"Run LLM agents or OpenRewrite"| P3["3. Validation"] P3 -->|"Verify via CI, tests & canary signals"| P4["4. Campaign Management"]
subgraph P4["4. Campaign Management (Shepherd Platform)"] YAML["Declarative YAML Config"] Engine["PR Generation & Rebase Engine"] Route["Queue Routing & Code Inbox Integration"] YAML --> Engine --> Route end ```
To manage the logistical complexity of distributing hundreds of automated pull requests to code owners, Uber engineered Shepherd, a campaign management platform. Migration authors define their campaigns using a declarative YAML file, specifying either a prompt for an AI agent or a deterministic script using tools like OpenRewrite. Shepherd orchestrates the PR lifecycle from end to end: generating targeted diffs strictly scoped to individual ownership boundaries, rebasing and refreshing PRs on defined schedules, routing them into appropriate team review queues, and synchronizing with Code Inbox. Demonstrating Shepherd in action, Ty Smith showcased a campaign upgrading internal Java services to Java 21 using deterministic OpenRewrite recipes, where the platform automatically generated clean, correctly scoped pull requests directly to the respective service owners. Describing the strategic realization that prompted the project, Ty Smith noted:
> “And we'd had a lot of discussions and seen that they had fundamentals that Uber hadn't invested before. Which was the ability to kind of scale out large-scale changes so that the AI can then build on top of that.”
- Organizes large-scale refactoring into four distinct phases: problem identification, transformation, validation, and campaign management. - Leverages both non-deterministic LLM agents (such as Claude Code) and deterministic engines (such as OpenRewrite). - Validates automated diffs using CI pipelines, unit tests, and staging or production canary signals before requesting human approval. - Exposes a dedicated Shepherd web UI driven by YAML configurations to coordinate, rebase, and track hundreds of migration pull requests. - Integrates directly with Code Inbox to deliver scoped PRs into team queues without manual intervention. - Successfully orchestrated fleet-wide upgrades of internal Java services to Java 21.
[29:02](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1742s) Automated Performance Fixes and Minion Integration
Ty wraps up the technical deep dive by demonstrating another practical application integrated into the Minion platform as an agent. Within Uber’s programming systems group, separate analysis tools continuously run to detect performance issues and generate high-quality diagnostic data. While Ty initially mixes up the name with an internal project called Dr. Fix, he clarifies that this particular agent ingests the performance data and generates code changes (PRs or diffs) to resolve the bottlenecks.
These automated changes are then piped directly through Shepherd, Uber's code review system. Each generated change includes standardized documentation explaining precisely how it was tested, how it was verified, and what the human developer needs to look for in order to review and land the code safely. With the deep dive concluded, Ty passes the presentation over to Anshu Chada to address the non-technical hurdles of leading an agentic shift.
```mermaid flowchart LR accTitle: Automated Performance Remediation Architecture accDescr: Diagram showing performance analysis tools generating data, feeding into the Minion platform agent, and creating PRs in Shepherd with verification details.
subgraph Analysis["Detection"] A["Programming Systems Tools"] -->|"generate diagnostic data"| B["Performance Issues"] end
subgraph AgenticCore["Minion Platform"] B --> C["Automated Fix Agent"] end
subgraph Review["Verification & Review"] C -->|"generate PRs / diffs"| D["Shepherd Platform"] D --> E["Standardized Review Brief<br/>(Tests, Verification, Safety)"] end ```
[29:53](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1793s) Business Uncertainty, Tool Churn, and Build vs. Buy
Anshu steps up to examine the human and business realities that complicate large-scale AI adoption. Using the Olympics as a timely visual analogy, he illustrates how the podium of leading AI technologies keeps rotating: the most powerful models for a given task change constantly, and the line between building in-house versus buying third-party SaaS shifts under their feet. In an engineering organization of Uber's scale, initiating projects like AutoCover (automated test generation) or AutoMigrate represents a massive capital and human commitment involving dozens of engineers over many months; leadership cannot afford to pivot on a whim every quarter.
To navigate this volatility without paralyzing execution, Uber leans on two core principles: architectural abstraction and organizational detachment from internal tools. By maintaining strict abstraction layers across platforms like Minion, the team can swap underlying foundation models or components seamlessly whenever superior technology emerges. More fundamentally, the engineering organization has had to cultivate a mindset that embraces obsolescence:
> “And so it's really important for us to not be married to the tech that we're building and being okay if something comes along like if the the co-founder cursor talked about the the auto the test coverage system that that might be coming a couple weeks. I'm really excited about that. It might make our auto auto cover infrastructure obsolete and that's okay because at the end of the day we need to deliver impact for Uber.”
[32:04](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1924s) People Challenges: Legacy Debt and Cultural Inertia
Beyond model selection, cultural and technical inertia present stubborn obstacles. Uber's monorepo and microservice landscape contain fifteen years of legacy code, spanning both world-class infrastructure and obscure, archaic systems that few remaining employees comprehend. Exposing this heterogeneous codebase to agents via Model Context Protocol (MCP) endpoints has proven to be an ongoing struggle.
Simultaneously, developer habits die hard. To show executive leadership what was possible, Anshu ran a hands-on session where four VPs landed production code in just 24 minutes—the first time any of them had shipped code in years. Yet despite such eye-opening demos, broader grassroots adoption across the company lagged behind expectations. Engineers are hardwired to write code from scratch in an IDE; handing autonomy over to background agents feels like an unnerving leap of faith. Top-down mandates to hit specific adoption metrics produced shallow improvements, but real cultural momentum only occurred through peer-to-peer evangelism:
> “Um so, that's been the the tactic that we're we're pushing on now is key promoters pushing techniques to their peers, because those promoters are typically engineers, and engineers trust other engineers as opposed to directors like me.”
- Top-down executive decrees artificially inflate tracking metrics without necessarily creating sustainable workflow shifts. - Showcasing tangible, peer-led wins in developer channels triggered organic spikes in tooling adoption. - Retrofitting older systems with modern MCP interfaces remains one of the heaviest engineering lifts for agent integration.
[34:13](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2053s) Measuring Business Value Beyond Activity Metrics
Objective internal indicators demonstrate that generative AI is transforming developer productivity at Uber: developer net promoter scores (NPS) and self-reported engineering satisfaction sit at all-time company highs, while AI-attributed code volume continues to surge. The adoption curve hit an aggressive inflection point once high-reasoning models like Claude 3.5 Sonnet and Opus arrived and were paired with Uber's Minion platform. A wide gap has emerged between casual users and power users who leverage agentic workflows at least 20 days a month.
However, Anshu stresses that these figures are strictly activity metrics rather than commercial outcomes. As AI infrastructure expenditures balloon, executive leadership expects a clear financial return:
> “You know, our CFO has has asked me uh what is the impact of this? Right? I You know, I can't put him to diffs. I need to show him what's the impact on on revenue.”
To bridge the gap between engineering activity and enterprise value, the team is instrumenting the end-to-end product delivery pipeline. Instead of counting diffs or landed lines of code, the platform team is benchmarking the cycle time from an initial product design artifact to the moment a feature experiment goes live in production, proving whether agentic tools actually compress time-to-market.
[36:01](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2161s) Confronting Spiraling AI Costs with Model Routing
Anshu bluntly summarizes the operational reality facing platform leaders: “the cost of AI is too damn high.” Since 2024, Uber’s spending on AI development tooling has exploded by at least 6x, evolving from a line item an engineering director could absorb within a team discretionary budget into an enterprise expenditure requiring explicit sign-off from the CFO. With GPU and memory hardware prices keeping external pricing elevated at vendors like Anthropic, Uber has had to adopt aggressive internal cost controls.
Rather than asking individual software engineers to manually balance cost versus capability, Uber's platform infrastructure automates the routing. For compound workflows orchestrated in Minion, the platform routes upstream reasoning and high-level architectural planning to premier, high-cost frontier models, while delegating low-level, repetitive code execution and linting to cheaper, high-throughput models. This keeps developer friction to a minimum while reining in token burn, a discipline that requires continuous tuning as Uber expands its enterprise toolbelt across Cursor, JetBrains AI, and Warp terminal environments.
- AI developer tooling expenses increased over 6x between 2024 and 2026. - Strategic tiered routing uses frontier models for project planning and cost-efficient models for localized task execution. - Newly onboarded tools like JetBrains AI and the Warp command line agent introduce distinct commercial billing structures that require continuous optimization.
## Notable quotes > [03:36](https://www.youtube.com/watch?v=i1tZN41VKcE&t=216s) And that's that's all culminated in this model where we imagine developers acting as their own tech leads. — Anshu Chada
> [18:41](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1121s) They're spending more and more time in planning and code review because there's so much more code being generated that they're being forced to do it. — Ty Smith
> [22:12](https://www.youtube.com/watch?v=i1tZN41VKcE&t=1332s) We really only want to put the high confidence changes that the developer really needs to focus on, not little nits. — Ty Smith
> [33:44](https://www.youtube.com/watch?v=i1tZN41VKcE&t=2024s) Um so, that's been the the tactic that we're we're pushing on now is key promoters pushing techniques to their peers, because those promoters are typically engineers, and engineers trust other engineers as opposed to directors like me. — Anshu Chada
## Mentioned Uber, Anshu Chada, Ty Smith, Dara Khosrowshahi, Michelangelo, Minion, AIFX CLI, Code Inbox, U Review, AutoCover, Shepherd, Claude Code, Cursor, GitHub, Phabricator, OpenRewrite, Model Context Protocol (MCP), Anthropic, OpenAI, LangFX
## Video description With Ty Smith and Anshu Chada, Uber Dev Platform. At The Pragmatic Summit: www.pragmaticsummit.com
Update on 11 March: the Uber team shared updated numbers as of March 2026:
- 84% of devs at Uber are agentic coding users (either using CLI-based agents or making more agentic requests than tab-completion in their IDE)
- 65-72% of code is AI-generated inside IDE-based tools. This number is, naturally, 100% for AI command line tools like Claude Code.
- Claude Code usage nearly doubled in 3 months — from 32% in Dec to 63% in Feb, while IDE-based tools (Cursor, IntelliJ) have plateaued.
See more context in this article: https://newsletter.pragmaticengineer.com/p/how-uber-uses-ai-for-development
Watch the session with Q&A also included: https://newsletter.pragmaticengineer.com/p/the-pragmatic-summit-recordings
0:00 Intro 6:11 Toil automation 8:02 Uber’s agentic platform architecture overview 11:16 The cross-functional tiger team 17:46 Async multi-agent workflow model 20:32 Minion background agent platform 26:55 Agent logs, observability, and debugging workflows 31:20 AI code review pipeline and quality grading 36:50 Testing 40:38 Migrations 43:55 Non-technical challenges
[Source](https://www.youtube.com/watch?v=i1tZN41VKcE)