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.
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.
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.
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 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:
- Receive a design problem
- Decompose it into multiple design tasks
- Define and describe a set of key moments worth producing design composition for
- 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)
- Organize and annotate the designs so that they are easier to read and review by humans and agents
- 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.
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.
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 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.