
Gamut
Codecademy's design system
Gamut started as a small pattern library nobody trusted, at a company that couldn't stop shipping to fix it. I turned it into one source of truth: components in code, mirrored in Figma, documented in Storybook. 40+ designers and engineers built on it without a single team pausing its roadmap.
This page covers how it got adopted: a small piece of every project, a contribution process simple enough that any designer on the team could add to it, and a dedicated design systems role to keep it going.
- Role
- Design Lead, Systems, then Design Manager
- Partners
- Web Platform engineering, Brand design, an 8–10 person design team across business units
- Scope
- Audit, tokens, components, Storybook, Figma library, contribution model, hiring
primary or shadow-primary, never a hex. One switch re-themes the product. Hover an alias to trace it. Aliases and values are Gamut's own, from its open-source repo.What's in it
Everything a product page needs, from buttons and forms to alerts, data lists and modals. Every component ships with its states and works in light and dark.
Motion with rules
Motion in Gamut comes from a small set of tokens. Four durations run from 150ms for small feedback to 350ms for the longest moves, one ease handles anything that changes state, and a few shared animations cover expanding, rotating and list changes, so components reuse them instead of inventing their own.
The signature is the lift. On hover, a card rises 4px toward the corner and a hard offset shadow appears behind it, the same shadow as the CTA, which carries the brand into motion.
Design debt no one owned
Codecademy's Figma library was incomplete and out of date, and nobody trusted it. Years of partial redesigns had left near-duplicate components on every page.
No PM was going to put design debt on a roadmap, and every team was mid-roadmap. The mandate from my Head of Design: raise the quality bar without deprioritizing anything.
- Audit first Catalogued every duplicate across live pages, design files and the library. Real numbers got people's attention.
- One tool Moved the team from Sketch to Figma so everyone worked from one library.
- One partner engineer Paired weekly with an engineer who was already fed up with component debt.
- Two pitches Reuse for engineers. "A little more scope now, faster shipping later" for PMs.
Room to stretch
The Learning Environment is where learners spend most of their time: instructions, a code editor and its output on one screen. It needed things no other page did, like a syntax palette that works in light and dark, line numbers, file tabs and a console.
We built those as a layer on top of Gamut. The learning theme starts from the core theme and adds an editor palette, so the type, colors, buttons and checkboxes are the same ones used everywhere else. The editor got to look like an editor, and the lesson still felt like Codecademy.
Three decisions that changed things
Where the docs lived, how we scoped the work, and who owned it.
1. Storybook as the source of truth
Designers trusted Figma and engineers trusted code, so the reference had to be something both would use. I moved it to Gamut's Storybook: real, embeddable components with their docs. The Figma library stayed linked and in sync, and every component shows its design and engineering status, so nobody has to ask what's ready.
2. Small scope, every project
Instead of asking for a system roadmap, I negotiated a slice of every project: upgrade the components you touch, and let engineers update the similar ones elsewhere on the site. To a PM it was an insignificant scope increase. Over a year that added up, and no roadmap had to pause.
3. Hiring for the role
As my scope grew across the Consumer business unit, I became the bottleneck. So I wrote up a new role, a Design Systems Designer, to sit between design and engineering and speak both languages. I hired a designer for it, managed them, and backed them when they pushed for bigger changes.
- Every designer contributing Any product designer could suggest or make component updates in Figma, with the systems designer as reviewer.
Most of the change happened in conversations with people, long before any of it became process.
What hiring for the role taught meOutcome
Gamut became one source of truth that both disciplines trusted. Every product team shipped critical projects on it, design and development got significantly faster, and design systems became a dedicated team. The foundations were part of what made Codecademy ready for its acquisition by Skillsoft.
- Trust repaired Design and engineering worked from the same components and the same names.
- A different culture Designers got comfortable working closely with engineering, and quality and speed both went up.
- Every business unit Each one had at least one in-depth Gamut collaboration.
- Recognized At an all-hands, leadership acknowledged the Platform team's impact on how we build.
What I learned
- Start with one partner Find one person who cares and get something working together. Seeing it work convinced people more than any mandate did.
- Show the mess The audit ended up being my best pitch. Once people saw all the duplicate buttons side by side, I didn't have to argue much.
- Ask for help sooner I stayed the bottleneck longer than I should have. Part of leading is noticing when something needs another person.
- Keep it moving Gamut stayed useful because people kept using it and changing it as the product grew.
If I started today
I'd put the system where people and tools can both read it: tokens, components and usage rules in code from day one, so a prototype made with AI uses the real system from the start. That's the idea behind Goodmake, the design tool I'm building now, which hands a team's references and notes to coding agents over MCP.
Design systems in earlier roles
Gamut wasn't my first system. Each earlier role had its own version of the same job: give a team shared pieces so the product stays consistent as it grows.

A design system for customer service: phone states, messaging, workflow snippets and consistent standards.

Consistency across iOS, Android and web, and how illustrations fit in an interface.

Cards, widgets and creation flows, built to be reused so we could ship quickly and onboard easily.