When component specifications lag behind implementation, the team starts building the system based on assumptions. At Uber, this turned into a systemic, large-scale problem—and was solved through agent-based automation.
The problem does not arise at the moment of writing specifications, but later—when the system begins to evolve faster than the documentation. The Uber Base design system supports hundreds of components, each implemented across seven stacks: from UIKit and SwiftUI to React and SDUI. Each component has density variations, platform-specific features, and strict accessibility requirements. The specification becomes the single source of truth, but the manual process of creating it does not scale: it is slow, depends on the author, and starts to become outdated immediately after the first change to the component. As a result, engineers rely on interpretations rather than contracts—leading to discrepancies and the accumulation of technical debt.
The solution the team arrived at was not to optimize the process, but to eliminate it as a class of tasks. Uber implemented uSpec—an agent-based system that generates specifications directly from Figma. The key decision here was to connect the AI agent to the actual data source (the design file), not to its projection in the form of screenshots or exports. This reduces the likelihood of interpretation errors. The second fundamental trade-off is local execution of the pipeline via Figma Console MCP: no design artifact leaves the company’s infrastructure. This limits integration flexibility but is critical for security and compliance with internal requirements.
The solution architecture consists of two layers. The first is the AI agent (in Cursor), responsible for interpretation: it understands the component structure, classifies states, selects accessibility semantics, and maps tokens. The second is the MCP (Model Context Protocol) bridge to Figma Desktop, which gives the agent read-write access to data: the component tree, variables, styles, and relationships between layers. The agent traverses the hierarchy, extracts actual token values, determines composition through slots and variants, and then fills out the specification template directly in Figma. Each section of the specification is encapsulated in a separate “skill” with strict schemas and validation. For example, for the screen reader section, the agent loads VoiceOver, TalkBack, and ARIA reference guides and selects values from the API rather than generating them heuristically—this is critical because an error in a single property breaks accessibility.
The key engineering decision is the separation of responsibilities: AI is used where interpretation is needed, while deterministic operations (rendering, insertion, cloning of structures) are performed via MCP. Figma plugins can extract data but cannot explain what it means. Pure AI, on the other hand, tends to hallucinate without a strict link to the source. uSpec combines both approaches, making the system robust at scale.
The result is a reduction in the specification creation cycle from weeks to minutes and the ability to regenerate documentation with every component change. This is not just acceleration, but the elimination of drift: the specification is now generated from the current state of the system. Uber does not provide formal quality metrics, but an indirect effect is a reduction in discrepancies between design and implementation and freeing designers from routine documentation tasks. It is also worth noting the role of the open-source layer: Figma Console MCP has become an infrastructural element, without which this approach would not be possible. This is a rare case where standardizing access to a tool directly impacts process architecture.