Skip to content
Case studies

Mythril

Towards an Agentic Design System

TL;DR

I'm building the documentation, design tools, and automations that enable coding agents to produce on-brand, fully tokenized design compositions from components in the codebase in Paper.

Role
Founding Product Designer
Team
1 Designer
Timeline
September 2026 – ongoing

At Mythril, I work on a small, AI-leveraged team as the sole founding designer. Most of my AI usage occurs earlier in the design process: as a brainstorming partner, or as a critical eye to review solution paths and ask tough questions. Our team is progressing towards end-to-end agentic workflows for Engineering, and I want Design to keep pace. This is how I'm trying to make that happen.

The Challenge

Asking agents to produce designs generally feels like a lost cause. The outputs might look good at first glance, but they fall apart on closer inspection.

It might look fine at first glance, but closer inspection reveals a lot of issues

Agents can take a design brief and produce something in Paper or Figma. But typically, the output has to be heavily reworked by hand:

Misalignment with product design language

Without access to your UI framework or theme, the agent will use colours, spacing and typography that isn't tied back to the codebase's actual classes or CSS variables.

This text's colour, font, font size, and line height are all misaligned with our product design language

Invented or incorrectly applied components and layouts

An agent can only guess at what components or layouts are available, let alone what configurations or UI patterns it should use.

This button is in the wrong position, the page layout has no top bar (which it should), and the button's size and padding don't match our button component's specifications

Poorly organized and documented structure

Failing to name layer structures and artboards leaves human and agentic reviewers alike having to guess what things are and how the compositions relate.

The design file and active page aren't named, and all the layers are just Frame - this composition will just cause confusion

The result is that every agent-produced design often costs as much or more to rework than it would have taken to build by hand.

But agents aren't the bottleneck. Like onboarding a new product designer, they need to have access to the same knowledge and tools a human designer would:

  • a design system that not only includes the UI kit, but also design guidelines, established UI patterns, and assertion checklists;
  • knowledge of design tools along with tool-specific quirks and limitations;
  • an understanding of a team's norms with respect to how work should be organized and formatted - like style linting, but for design files;
  • and probably a few more things, besides.

A Design System for the Agentic Era

I've built documentation and tooling that bridges much of the gap between design agents and our product's design language. At a high level, its components include:

  • design production skills for Claude and for Qwen on Hermes, encoding the actual design workflow and formatting quality standards to guide agentic work;
  • a projection layer that includes JSON configuration files and scripts that bridge the codebase, the design system, and the canvas tool, so that a component in code and a component on canvas are the same object, not a redrawn approximation;
  • agent-facing "gotchas" or documented quirks of the design tools themselves, so agents stop making the same tool-specific mistakes a new human hire would also make; and
  • annotations built into the output, linking outputs back to design intent so a human reviewer can evaluate the why, not just the what.

With this initial solution, an agent can:

  1. Receive a design problem
  2. Decompose it into multiple design tasks
  3. Define and describe a set of key moments worth producing design composition for
  4. Produce design compositions using a known set of components and tokens, based on established design patterns, and project that design work into a design canvasing tool (in Mythril's case, Paper)
  5. Organize and annotate the designs so that they are easier to read and review by humans and agents
  6. Review and iterate on the designs based on a checklist of declarative design guidelines

(Early) Results

Three weeks in, the results are anecdotal and qualitative yet very promising:

Better alignment with product design language

Design agents read configuration files for the theme as well as for each component they decide to use, so they know what tokens (and thus styles) to use as they assemble design compositions. The result is that designs look consistent with our product's established design language.

Inspecting this button shows tokens were used for size, spacing and colour - all of which come directly from our product's theme configuration

Component compositions from the codebase

Since agents read component configurations, they also understand their composition and can name those layers on creation. It's easy to scan the layer structure and know what you're looking at because its name matches an actual component from the codebase.

It's easy for both humans and agents to see (and learn) the structure of components simply by reading their layer structure

Organized and annotated

Just as engineers should comment their code for future reviewers, design agents can name their design files and pages to make them easier to find, and make use of annotation components to communicate design intent or interactions.

The agent created the file with a semantic name, added a Cover page with a thumbnail to make it easier for humans to find from the dashboard, and added notes about the design for reference.

The net effect of this system is that designs need significantly less rework and review time. That means more time for me to spend on harder design problems instead of wasting tokens and time correcting AI output. And it's allowed engineers to move faster through build, because what they're handed actually matches what exists in the codebase.

This is ongoing work. Some of the next steps are to see whether the same system holds up as more of the design system's surface area gets covered, and as Mythril expands to different platforms or to multiple product offerings.