Building an AI-Native Software Factory Beyond the Tools

Overview

Every software engineer at a modern tech company likely already has access to an AI coding assistant. Whether it is Claude Code, Cursor, or Codex, individual developers are faster than before. Yet, when leadership asks where the organizational AI-native software factory is, the answer is often uncomfortably vague.

The core insight driving this shift is that personal coding tools solve only one part of a larger problem. They accelerate a single developer at their keyboard, but they do not address the systemic needs of a company running hundreds of autonomous agents. The challenge is no longer about the model; it is about the infrastructure, governance, and visibility required to operate at scale.

The Limits of Individual Tools

A coding tool makes a developer faster within their own session on their own laptop. A company running dozens of agents, however, hits four distinct limits that no single tool can fix.

First, laptops cannot run a fleet. At Uber, a growing share of agent sessions starts without human intervention, handling tasks like code review, CI fixes, and on-call triage. A laptop sleeps when its owner leaves, making it unsuitable for persistent, managed workflows. Uber describes the move from laptops to managed environments as its core strategic shift, citing the need for complete control over model routing and spend.

Second, security and access become critical concerns. DoorDash’s platform team notes that laptops hold SSH keys and VPN sessions. Handing autonomous agents that level of access creates a potentially large blast radius. Meanwhile, companies like Ramp found that engineers could only run a couple of sessions on a laptop before hitting performance ceilings.

Third, every team invents its own way. When given a coding agent, a hundred developers create a hundred setups. This leads to duplication, poor quality, and inconsistent security rules. As Anthropic suggests, writing each rule once as a shared skill is essential. A factory is where the company’s way of working lives once, for every agent, preventing the splintered adoption that Google’s DORA research warns against.

Finally, nobody sees the bill. When engineers pick their own tools and models, the total cost remains invisible until the invoice arrives. Uber reported that its AI costs rose sixfold since 2024, spending its entire annual budget in just four months by June. Much of this waste goes unnoticed from a single laptop, where simple sessions might be routed to expensive models unnecessarily.

“If your engineers are spending $1,000 per month more because of LLMs and they are 10% more productive, that’s too cheap.”

This quote from Shopify’s Farhan Thawar highlights that the goal of a factory is visibility first. Only by knowing the cost per merged change can leadership make informed trade-offs.

The Six Building Blocks

Uber has published extensively on its software factory, emphasizing that most of its six building blocks are not coding agents. Instead, the company uses off-the-shelf tools like Claude Code, Codex, and OpenCode. The value lies in the platform built around them.

Other companies with established factories have made similar calls. The strategy is to keep buying the agent while building the setup that allows it to operate reliably across the organization. This includes everything from model gateways and identity management to test generation and code review systems.

The objective is to create a system where work starts from a ticket or an alert, with no one at the keyboard. Agents must run in the cloud, under rules every team shares. This ensures that the speed gains of individual developers translate into organizational velocity rather than isolated pockets of productivity.

A Practical Roadmap

Building an AI-native factory requires a measured approach. The recommended first step is to measure where your team’s work piles up today using your own git history. Identify the bottlenecks and the toil that nobody wants to do by hand.

Then, put one bought agent on that specific toil. Uber found success with agents handling migrations and code review well before tackling feature work. This proves the platform’s value without overcommitting resources.

Next, build only the platform that first line proves you need, usually a model gateway. Throughout this process, track what merges, what it costs, and how often it breaks. Uber prices every agent the same way: by the cost per unit of work, such as the cost per merged pull request.

The rollout order matters, as does the plan for developers who prefer not to change their workflow. Your developers should keep the agents they like, while your company gains a factory that ships. By focusing on the system around the agents rather than building proprietary models, organizations can achieve scalable, cost-effective AI integration.