The package is the contract

Two weeks ago I started building a design system, with the help of agents, that will serve our production iOS app and internal SwiftUI prototypes.

It's currently built as a standalone Swift package, not a module inside the app. I want designers prototyping in Xcode to use the exact same components that ship to production, so they can build a flow, hand over the project, and skip the translation layer. The package is the contract between design and engineering.

Figma is still useful, but it's a web renderer approximating native behavior. You can't test Dynamic Type, feel haptics, verify high-contrast mode, or observe Reduce Motion there, because you're designing in one medium and shipping in another. So I built a living catalog iOS app as the single source of truth, with every component, token, and effect testable natively on the device you're building for.

We still have a Figma plugin to experiment, and to have a visual representation that originates from the code of the components and tokens: same names, same spacing variables, same variants, same booleans. When a designer says "Button, intent: danger, size: medium," engineering knows exactly what that means. Zero interpretation.

Designers currently spend days (or weeks, depending on scope) in Figma to design a flow, or entire features. Engineers then figure out if components exists, approximate spacing and font values, ship something close, then we need to polish. Documentation drifts because Figma says one thing, code does another, the GitHub issue describes a third, and new hires have no idea what the source of truth is.

Now we have a shared token layer (colors, typography, spacing, borders, haptics, motion) that powers SwiftUI, UIKit, and Figma from one source. Anyone can open the catalog on a device and see exactly what exists and how it behaves. It even has code snippets, and live previews.

How it works: describe what you need in plain language. An orchestrator agent plans the work and coordinates specialized agents: one for tokens, one for SwiftUI, one for UIKit, one for Figma, one for the demo catalog. They catch their own errors, enforce formatting, validate accessibility, keep docs current, bundle commits by theme, draft descriptions, and review each other before anything lands.

I've got a working POC on a local branch where an agent replaced two production components with design system equivalents in about 30 seconds. A couple of hiccups, but the build passed and tokens resolved.

Next: coordinating with engineering (and agents) to incrementally refactor the production app, replacing ad-hoc implementations with design system components, always with human approval at each step. Not a big-bang migration, a steady, auditable rollout.

This should reduce the time spent designing, building, and polishing, give every discipline a shared, testable, native source of truth, and let the boring parts run on autopilot so humans can focus on the interesting decisions.

It's still early, but I'm convinced this is where design systems are heading.