case study · anaconda · design systems
one ai-connected design system that cut our first dashboard’s handoff from months to a week
Anaconda’s teams were rebuilding the same UI in Figma and in code, with a merger deadline to ship one unified platform. I led the foundations and pattern library for a shared, AI-connected design system, aligning design, engineering, and leadership across three merged companies.
role
Product designer, led foundations and pattern libraries
team
1 PM, 3 designers, 2 engineers
timeline
4.5 months, in two phases
scope
Tokens, components, 9 patterns, AI workflow
3 teams
adopted it first, in a rollout to 5 of 6 products
1 week, not 1–2 months
from design to dev handoff on our first dashboard
1:1
Figma components now match code components one to one
9 patterns
defined and documented in 6 weeks, built on the foundations
at a glance
the six calls i made that shaped it.
01 · foundations
choose a foundation we could own
shadcn-svelte, since Kendo wasn’t built for Svelte
02 · foundations
learn the rules before rewriting them
reverted our atomic restructure to match the code
03 · foundations
spend the debate where users notice
kept our approved palette, adopted shadcn spacing
04 · patterns
define what a pattern is
a shared definition, built from a CEO-approved prototype
05 · patterns
give patterns one front door
patterns separated from rules, owned by two designers
06 · ai workflow
make ai build from the system
tested Claude against the library, then gave it rules to build from our patterns
the problem
a merger exposed an outdated system, and it was costing us months.
Three companies merged mid-project, with a deadline to ship their products as one unified platform. Every team suddenly needed to design and build from the same place. We needed one system that let us move quickly and consistently, and that AI tools could build from.
what it cost the business
1–2 months for routine UI changes
Even small updates, like changing a menu bar or matching a table to our other products, took one to two months, because teams rebuilt the same UI in Figma and again in code.
why it kept happening
an outdated system, three ways of working
The old system was poorly structured, out of sync with code, and not built for AI design. The merger added two more ways of working on top of it.
decision 01 · choosing the right library
choose a foundation we could own.
the constraint
the decision
I led the research and scored six libraries against our Architecture Decision Record. I recommended shadcn-svelte because its code lives in our repo, where engineers and AI build from the same source.
the tradeoff
We’d build and maintain more ourselves, but owning the source let us fix accessibility and theme it to our brand.

Library comparison scored against our Architecture Decision Record.

Top: one parent with boolean properties, simpler in Figma.
Bottom: the structure restored to match code.
decision 02 · making shadcn foundations our own
learn the rules before rewriting them.
the constraint
Our designers knew atomic design from Kendo, which favors one parent component with variations. We wanted shadcn components like Input and Input Group merged the same way, and I started doing it, until I realized they’re separate in code.
the decision
After confirming with our developer, I reverted the merge and kept shadcn’s structure in Figma, so every Figma component matches one in code that engineers and AI can build from.
the tradeoff
Designers lost a familiar Figma model, but Figma finally matched the code one to one.
Our shared definition of a pattern, and the criteria every pattern had to meet, set in the Miro workshop.
decision 04 · defining a pattern
define what a pattern is before building one.
the constraint
Each merging company defined a pattern differently, and with products mid-redesign, there were no finished screens to build from.
the decision
I led the research and competitive analysis, then a three-person Miro workshop to set a shared definition and success criteria. For screens, I found a tiger-team prototype the CEO loved.
the tradeoff
Building from one demo risked narrow patterns, so we treated the library as living.
decision 05 · building the patterns
give patterns one front door.
the constraint
The team was blurring patterns and rules. One designer kept pushing data rules when he really wanted to write component usage guidance.
the decision
I pushed back on mixing the two and split patterns from rules. Instead of shutting him out, I redirected him to the rules workstream, the work he actually wanted. Leading two other designers, I set the sprints, Figma structure, and definition of done: designers from the merged teams could build real screens with it.
the tradeoff
One front door slowed one-off requests, but ended the days of every designer inventing their own patterns.

A pattern wasn't done until it had all four parts: the component, its anatomy, its variants, and its states. That way designers and AI tools built it the same way every time. Shown here: the filters pattern.
ai testing
teaching ai to build from the system, not around it.
We needed AI tools to build from the system, so I set up how that would work: make sure the components held together, pick the tool engineers could build from, give it rules to follow, then run it end to end. Every gap it found became a fix in the library.
01 · make sure the pieces hold together.
Before any AI testing, I checked that every component linked back to its parent the way it should. If the structure was off, AI would copy the mistakes into every screen it built.
Testing components built on our foundations, before we started on patterns.
02 · pick the tool engineers could build from.
I compared Claude Design and Claude Code on how quickly they generated usable screens, how closely they followed our system, and how well they organized layouts. Claude Code won, because it built from our real components.

claude design
Quick concepts for stakeholders, but the output stayed a prototype, not something engineers could build from.

claude code
Built the screen in Figma from our own components. The pieces it couldn’t link showed exactly which patterns were missing.
03 · give it rules to follow.
I gave Claude Code a skill that tells it to build from our patterns first, and to flag when a pattern doesn’t exist yet. Each flag told us which pattern to create next, so the AI work fed the library instead of working around it.

04 · from prompt to screen in minutes.
What used to take months of rebuilding UI now starts with one command and a prototype image. Claude Code builds the screen in Figma from our library, I check it for pattern breaks, and it goes to dev.
My /build-screen skill turns a prototype image into a Figma screen built from our foundation and pattern libraries. I review it for inconsistencies and pattern breaks, then it’s ready for dev handoff.
outcome
a system teams actually adopted.
One library now runs from Figma to code, and both designers and AI tools build from it. The clearest shift was with engineering: one engineer who used to treat my Figma files as suggestions helped build and test the new system, and by the end he was building straight from the file.
design to dev handoff
1–2 months → 1 week
Our first dashboard on the system. Engineers built straight from the Figma file.
adoption
5 of 6 products
Every product but Desktop, which is being folded into the new platform.
early user testing
a cleaner, clearer product
Users liked the dark mode and new navigation. “This looks much, much cleaner.”
one company, a dozen products, one system.
Before the system, every product had its own navigation, tables, and buttons. Now they share one app shell and one set of components.
before
Five tables from across Anaconda's products before the system, and every one has a different UI.

Anaconda Cloud (PSM): environments table

Outerbounds integration: admin view

Anaconda Cloud (PSM): audit logs table

Anaconda Navigator: developer view

anaconda.org: public user view
5 products, 5 different tables.
Same company, no shared system.
after

The new Anaconda Platform: the merged companies' products, brought together on one system.

The new Anaconda Cloud experience for developers, built on the system.
reflections
what i’d bring to the next system.
01
check the code model first
A simpler Figma structure can create more work in code. I now confirm the implementation model with engineers before restructuring anything.
02
set ownership on day one
Narrowing to two design owners with wider team feedback worked better. Next time I’d set owners and review criteria from the start.
03
test real screens from sprint one
AI-built screens revealed gaps that component reviews missed. I’d bring those tests in from the first sprint, not the last.
04
measure what the system changes
I left before the wider rollout, so I couldn’t track results. Next time I’d set baselines from day one and measure adoption rate and time to handoff across every team.

