Yassine Bentaieb
CodecademyWork
Codecademy case study

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
Docs
gamut.codecademy.com
Components ask for a role, like 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.

A spread of Gamut components, labelled with their names in code. Switch the mode to see the whole kit re-theme.

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.

Every demo uses Gamut's real values: the timing tokens, easeInOut, the core elevation and the three shared animations, from its open-source repo. Switch to ¼× to watch them slowly.

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.

Many near-identical buttons, one component. The count is illustrative.

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.

Switch layers to see what came from Gamut's core and what the learning theme added, and flip the editor between its dark and light palettes. Role names and values are from Gamut's open-source repo.

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.

One page per component: status, a live preview in both modes, the code and its props.

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.

Illustrative: the projects, order and counts are made up to show the mechanism. Purple marks a component a project touched, green one updated alongside it.

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.

How a change moved once the role existed. Anyone could propose, and the systems designer and a platform engineer took it to release.
  • 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 me

Outcome

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.

40+designers and engineers on Gamut
0roadmaps paused to get there
1new role, defined and hired

What I learned

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.