Decoding Uber's AI software factory: what a five-person team should copy

A decode of Uber's published setup around Claude Code and Codex, sorting what small teams should copy now from what only pays off at Uber's scale.

Picture a five-person product studio. Everyone runs Claude Code or Codex, and two of them keep three sessions open at once. Each developer has their own prompt files, their own habit for picking a model and their own sense of when a diff is ready. Pull requests now arrive faster than the two seniors can read them. The monthly AI invoice is one number, and nobody can say which work it paid for. Then a client forwards Uber's software-factory talk with a one-line note: where's yours?

The AI Thinker's How to build an AI-native software factory (October 5, 2026) walks through what Uber has published about the system around its agents. Its central point fits that studio: Uber did not build a coding agent. Its developers use Claude Code, Codex and OpenCode, and "none of its six building blocks is a coding agent." You keep buying the agent. What's left to build is intake, cloud runs, shared rules, review and a bill you can read. This decode sorts what a small team should copy from what only pays off at Uber's size.

What it is

This is a guide built from Uber's own disclosures, not a product. The numbers come from an Uber Engineering post, "Running a Software Factory Efficiently at Uber Scale," by Uday Kiran Medisetty, as summarized by CellCog and explainx.ai in late August 2026. Both report that more than 70% of Uber's pull requests are attributed to local or cloud agents, that employees have built 3,600+ agent skills running 30,000+ times a day, and that from February to mid-August 2026 weekly active users grew 7x and weekly agent requests 9.4x while total AI spend stayed relatively stable since April.

The AI Thinker frames the factory around four limits that no coding tool fixes alone. Each maps to a pain in the studio above:

Uber sorts agent use into four layers: a handful of specialized cloud agents (Minion writes PRs, uReview reviews them, plus agents for experiments, alerts and maintenance), one general front door called Cortana, developer sessions loaded with shared skills, and raw Claude Code, Codex or OpenCode sessions. Each specialized agent is priced per outcome: cost per merged PR, per review, per alert. According to explainx.ai, Uber picks each agent's model by building a benchmark from its real work; for uReview that meant real PRs with known bugs, scored on precision, recall, F1 and cost per PR. Switching models improved F1 and cut cost per PR.

The cost levers, per CellCog and explainx.ai: default subagents to a cheaper model (Uber calls this "the most impactful lever"), move interactive sessions to a 1-hour prompt-cache TTL because engineers idle past five minutes, compact at 400K tokens, default reasoning effort to medium, and route 1,000+ MCP servers through one gateway as CLI commands instead of loading every schema.

Alternatives to building your own floor, both with fetched pages:

Who it's for

Pick this up if you already pay for coding agents, your review queue is growing, and you can't say what a merged change costs. The parts that transfer to a small team are cheap: one shared skills and instructions folder, one agent on toil, a small benchmark from your own work, and cost per merged PR as the number you watch.

Skip the Uber-scale parts. A front-door agent like Cortana, a 24-million-node context graph, a gateway over 1,000+ MCP servers and five specialized agents exist because Uber has thousands of engineers and a platform team. The AI Thinker says plainly that none of this is a template to copy. If you're a solo developer with one repo and a readable bill, you don't have the problem yet.

Before and after

Before:

  1. Each developer starts sessions by hand on a laptop, with private prompts and rules.
  2. Model choice is habit; the expensive model runs the easy tasks.
  3. Diffs land in review unchecked, and two people absorb all of it.
  4. The invoice arrives as one line item.

After, following the AI Thinker's suggested order:

  1. Measure where work waits today, from your own git history.
  2. Put one bought agent on toil. At Uber, agents took migrations and code review well before feature work.
  3. Write shared rules once, as skills every agent loads.
  4. Run that agent in the cloud, triggered by a PR, ticket or alert. Port's argument for cloud factories is that rules only apply everywhere when the run happens somewhere the team controls; planning and picking up a stopped session can stay local.
  5. Verify before a human sees the diff. Firecrawl's guide cites Spotify's LLM judge vetoing about 25% of agent sessions and Faire requiring two human reviews on agent-authored PRs.
  6. Track what merges, what it costs and how often it breaks, per unit of work.

Try it

The sources describe a sequence, not an installer. The smallest real steps they support:

  1. Find your slowest step. The AI Thinker says to start from git history: where do changes wait? None of the sources give a script for this.
  2. Write rules once. Per meetzest.com, Codex and Copilot both read AGENTS.md and load skills from .agents/skills, so one folder serves both tools. Codex's GitHub review follows a ## Code Review Rules section in the AGENTS.md nearest the code, and Copilot code review reads AGENTS.md as agent instructions.
  3. Put one agent on review. Tag @codex on a pull request or turn on automatic reviews (Codex comes with ChatGPT Plus at $20/month or Business at $25 per user, October 2026 pricing per meetzest.com). Or use Copilot code review, included in Copilot Business per GitHub's page.
  4. Build a tiny benchmark. explainx.ai suggests a ten-task eval from your own agent's transcripts, re-run monthly. Uber's version used real PRs with known bugs; you can seed yours from bugs you've already fixed.
  5. Script runs from CI if you need unattended starts: meetzest.com lists codex exec "…" and copilot -p "…" as the scripted entry points.
  6. Tune cost settings your harness exposes: a cheaper default model for subagents, longer cache TTL for interactive sessions, medium reasoning effort. These are Uber's choices as reported, not universal defaults.

Where it breaks

Review is the ceiling, not generation. Augment Code cites Faros AI telemetry showing teams with high AI adoption merged 98% more PRs while review time rose 91% and PR size rose 154%. Firecrawl reports that in dotnet/runtime, agents opened 878 PRs and two reviewers wrote 36% of the feedback. Adding agents to a five-person team without verification first just moves the queue.

"Attributed to" is not "shipped unreviewed." CellCog stresses that Uber's 70% figure comes with human reviews and escalations. Cost per merged PR is also a proxy: our read is that a cheap PR that gets reverted isn't a win, which is why Uber pairs it with quality metrics like revert rate, per CellCog.

What's unconfirmed:

Most corroborating sources have something to sell: Port, Augment Code and Firecrawl sell factory or agent tooling, and meetzest.com sells AI usage analytics. Lock-in runs both ways in the alternatives: Copilot's agent features are built around GitHub, and Codex runs only OpenAI models under five-hour and weekly limits. Meetzest.com reports one of its engineers hit Codex's weekly limit on 7 days in September.

Sources