AI Summary
5 min readUber’s AI infrastructure did not emerge from a blank slate. It was retrofitted onto a decade of custom developer tooling built to handle the company’s unique constraints: thousands of microservices, hundreds of millions of metrics per second, city-level sharding, and a three-sided marketplace. Udai Kira Mendisedi, one of Uber’s longest-tenured engineers and now a leader in agentic AI, walked through how the company’s pre-AI platform investments—DevPods, Slate, Michelangelo, Jaeger, and others—became the foundation for a new generation of AI-native tools. The result is a development environment where agents can self-validate, self-heal, and even improve the codebase autonomously, but only because the underlying systems were already built for automation.
The pre-AI platform that made agentic AI possible
When Udai joined Uber in 2015, the company had exactly two services: Dispatch (Node.js) and API (Python). As Uber expanded into new countries and products, teams needed to build quickly, and the engineering organization grew from roughly 600 engineers to several thousand. That hypergrowth forced Uber to build its own infrastructure because off-the-shelf solutions could not handle the scale or the rate of change.
Continue reading the full summary in the app — free to try.
Read Full Summary →Free • No credit card required
Never miss an episode of The Pragmatic Engineer
Get every new episode summarized in your inbox — free, ~5 minutes to read.
No spam. Unsubscribe anytime.
What you'll learn
- 1 (00:03) **Episode Introduction** - Host Gergely Orosz introduces the episode: an exclusive, visuals-heavy look at Uber’s internal developer and AI tooling with long-tenured engineer Udai Mendisedi.
- 2 (02:16) **Udai’s Background & Uber’s Early Architecture** - Udai joined Uber in May 2015, working on the real-time API team when Uber had only two services: Dispatch (Node.js) and API (Python).
- 3 (05:34) **The Microservices Boom and Platformization** - Uber invested heavily in service infrastructure (metrics, tracing, monitoring, deployment) to support the explosion from two to thousands of services.
- 4 (08:33) **Pre-AI Internal Tools: UOwn, M3DB, Michelangelo, Cadence** - Uber built custom tools because off-the-shelf products couldn’t handle their scale and unique constraints.
- 5 (14:51) **DevPods: Cloud Development Environments Ahead of Their Time** - In 2017-2018, Uber moved from micro-repos to monorepos, which made local builds slow and setup painful.
- 6 (18:35) **AI Foundations: Model Gateway & Michelangelo Gen AI** - Uber invested early in hardware- and model-agnostic building blocks to keep pace with the rapidly changing AI landscape.
- 7 (24:06) **AIFX: Harness-Agnostic Developer Experience** - To make it easy for engineers to switch between coding harnesses (Cloud Code, Codex, Cursor), Uber built AIFX, a wrapper pre-installed on DevPods.
+ Full timestamped outline available in the app
Show Notes
Brought to You By:
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable
• Linear – the product development system for teams and agents
• WorkOS – everything you need to make your app enterprise-ready.
—
What do developer tools look like inside of Uber, today? They are very different from what you would see at most places. For example, can you guess what service a system called DevPods, Code Inbox, Slate or Wisdom would be providing to engineers?
Today’s episode is a deepdive into the day-to-day tools of devs at Uber, our tour guide being on of Uber’s longest-tenured engineers: Uday Kiran Medisetty. Uday is one of the few Distinguished Engineers at the company, and leads much of the work on agentic AI, today.
With Uday, we talk through how Uber’s developer infrastructure prepared it for AI agents. We look at the systems Uber built before generative AI and the new tools that connect agents to its code, internal services, and engineering knowledge. Uday explains how engineers use background agents, why tools like Slate make development (and bugfixing!) more efficient, and how code review is changing. We also cover Uber’s approach to token costs and how it measures productivity as the engineer’s role changes.
Timestamps
00:00 Intro
02:48 Uday’s early days at Uber
05:40 Uber’s move to microservices
07:55 Uber’s engineering team, then and now
09:05 Developer tooling before AI
16:03 DevPods
19:28 Building for AI agents
29:27 MCP gateway
34:37 Agent Skills repo
38:46 The context graph and Cortana
47:54 PRD and ERD tool
50:45 Minion
54:46 Testing and code review with Bazel, Slate, and Capri
1:12:26 Edge Gateway, Shepherd, and Wisdom
1:21:33 The changing role of engineer and measuring productivity
1:30:40 Uday’s favorite new products
—
The Pragmatic Engineer deepdives relevant for this episode:
• How Uber uses AI for development: inside look
• Scaling Uber with Thuan Pham (Uber's first CTO)