part 1: foundations

accelerating anaconda with an ai-connected design system

overview

Anaconda’s designers and developers were working from disconnected Figma libraries and code, so every screen needed manual alignment and handoffs dragged. As foundation and pattern design lead, I helped choose shadcn-svelte as our base, organized it into a shared Figma system, and connected it to Claude Code and Claude Design through MCP. Three product teams adopted it, and design-to-engineering handoff dropped from weeks to days.

Using Shadcn as a foundation, I led the creation of Anaconda’s new design system and pattern library; I connected both of these libraries using MCPs to Claude Code and Claude Design, helping our designers build and developers at a rapid velocity.

Role

Lead Product Designer for
Foundation and Pattern Design

product

Shared foundation for Anaconda’s product portfolio

collaborators

Product manager, 3 designers, and 2 engineers

timeline

3 months

constraints

Acquisition-related uncertainty, competing stakeholder priorities, and framework limitations

impact at a glance

3 product teams

adopted the system as the foundation for an org-wide rollout

weeks → days

design-to-engineering handoff time

2–4 weeks

from idea to handoff with the AI-assisted workflow, down from 1–3 months

the problem

Anaconda’s designers and developers need a way to prototype, build, and ship consistent screens faster, because disconnected design libraries and code require manual alignment and repeated work, which slows handoffs and delays delivery.

Business Need

Anaconda needed to ship products faster while reducing design and development costs. A shared, AI-connected design system would cut repeated work, speed up handoffs, and help teams deliver more with existing resources.

Design and Engineering Need

Designers and developers needed shared, reliable building blocks to quickly prototype ideas, hand off designs, and build screens without recreating components or resolving inconsistencies between Figma and code.

foundation

Choosing a foundation built for speed

We compared leading component libraries to find a foundation that could support our new stack, work with AI tools, and help designers and developers move faster together.

our criteria

What we needed from our foundation

Guided by our Architecture Decision Record, we evaluated each library against five requirements:

  • Svelte Support

  • Compatibility with Ai-assisted design and code generation

  • Code ownership and extensibility

  • Accessibility

  • Flexible theming

our recommendation

Why we recommended shadcn-svelte

Built for our Svelte stack

Aligned with our chosen framework and gave design and development a shared starting point.

a lightweight foundation

Provided the flexibility to build around the components we needed.

Code that our team and ai could work with

Components lived in our repository, giving developers control and AI tools access to the code they needed to build on.

accessibility we could inspect and improve

Access to component source code made it easier to evaluate accessibility and address issues directly.

system structure

turning a component library into a shared system

I organized the Figma library, prioritized delivery, and defined when components were ready for engineering, giving the team a clear path from foundations to reusable patterns.

METHODOLOGY

Creating structure with atomic design

shadcn gave us the building blocks. I used atomic design to organize them into foundations, components, and patterns—defining how they fit together to create consistent screens.

library structure

Making the system easy to navigate and deliver

I organized the library and delivery process so designers could find what they needed and engineers knew what was ready to build.

ORGANIZING FIGMA

applying atomic design

I separated foundational elements, components, and patterns into clear groups so designers could find, reuse, and understand how they fit

Planning delivery

building in the right order

I planned foundations and variables for Sprint 1, then dependent components for Sprints 2 and 3, tracking delivery in Jira.

defining readiness

Setting a shared standard

I added acceptance criteria to each component’s Jira story, giving designers a checklist to complete before handoff and engineers a clear standard for what was ready to build.

component design

making the library our own

I applied Anaconda’s visual foundations to the prebuilt components, then we checked token mappings and layout rules and reviewed accessibility across light and dark modes.

the atoms

applying Anaconda’s visual foundations

I customized colors, typography, spacing, border radii, elevation, icons, and logos to establish a shared visual foundation.

the foundations

checking every component against the rules

We reviewed component sizing, spacing, and styling, checking that color and typography tokens were mapped correctly throughout the library.

the review

Improving accessibility and trimming what we didn’t need

We reviewed components across light and dark modes, corrected contrast issues, and removed unused components to keep the library focused and easier to maintain.

Testing revealed insufficient text contrast in dark mode. We adjusted the muted-foreground token to improve readability.

constraints & tradeoffs

Adapting our approach to keep design and code aligned

Our existing component structures and token conventions didn’t always fit the new library. I adjusted both to keep Figma aligned with implementation.

constraint 1

Restructuring components to match code

Inputs were initially grouped under a single parent component with Boolean properties. When that structure didn’t match implementation, I returned them to shadcn’s Figma structure so design and development followed the same model.

constraint 2

Rethinking token names to protect the connection

Token naming conventions carried over from our Kendo library caused implementation issues. I restored the expected names, remapped affected components, and checked color and typography mappings across light and dark modes.

The token names required to keep the new library aligned with code.

The naming conventions carried over from Kendo that caused implementation issues.

constraint 3

finding common ground across teams

Acquisitions brought together teams with different product identities and expectations. We worked through decisions about color and component styling, clarifying what belonged in the shared library and what needed broader brand input.

Different views on the Storm palette highlighted the need to involve new stakeholders in color token decisions.

Teams had different preferences for focus states. We adjusted the effect while retaining shadcn’s default border.

testing

Putting the system to work with AI

I led tests of whether Claude could turn our Figma library into consistent patterns and screens. Each iteration showed where the system worked and where it needed clearer guidance, shaping the pattern library that came next.

  1. Checking consistency by building two screens by hand

We assembled screens in Figma to check how components worked together before testing AI-generated layouts.

  1. Comparing Claude Design and Claude Code

I tested both tools to see how quickly they generated usable screens, how closely they followed our design system, and how well they organized layouts.

Claude design

  1. Imported our foundations into Claude Design from the Figma file.

  1. I asked Claude Design to recreate one of our desktop prototype screens from a screenshot.

  1. The output stayed in prototype format: great for quick concepts to show stakeholders and clients, but not usable for developer handoff.

CLAUDE Code

  1. Connected Claude Code to our foundations library through a Figma link.

  1. I gave Claude Code the same prototype screenshot and asked it to build the screen in Figma.

  1. The Figma output was excellent. Not every component was linked, and the gaps showed us exactly where we needed patterns.

outcome

A shared system teams actually adopted

The foundations became the shared starting point for Anaconda’s product teams, and the base for the pattern library that followed.

before

Figma libraries and code built separately

Every screen aligned by hand

Handoffs took weeks

AI tools had nothing reliable to build from

after

One shared system in Figma and code

Tokens mapped to code, components ready to build

Handoff in days, adopted by 3 product teams

Claude Code builds on-system screens from the library

reflections

Building a better system meant rethinking how we worked

Leading this system end to end changed how I approach ownership, from shaping the workflow to keeping delivery on track.

1

learn the rules before rewriting them

I learned to understand the system’s structure and check with developers before changing it. What felt simpler in Figma created extra work in code.

2

Invite input, clarify ownership

Midway through, we narrowed ownership to two designers, with the wider team providing feedback. That worked better. Next time, I’d establish owners and review criteria from the start, then stick to them.

3

keep testing as we build

Testing real screens with Claude revealed gaps that individual component reviews missed. Next time, I’d bring those tests in earlier to refine the foundations and patterns as we built them.