
Table of contents
Table of contents
By signing up, you agree to Miro's Terms of Service and Privacy Policy.
How to embed localization, accessibility, design system, and content design in everything you build, by default.

Alice Desmoulins heads the localization team at Miro, where she has worked for over four years helping grow presence and distribution in the company’s strategic markets. Before Miro, she led and managed the localization team at Alteryx, a data analytics company. She works to understand Miro’s global opportunities, how to design the product for Miro’s global base, and build the internal technical platform needed to scale localization across the business.
Last published
When teams at Miro started using AI tools to design and code faster, our team had a stark realization. If we kept working the way we always had, we'd show up at the wrong time of the process, if at all.
I joined Miro to build and lead its first localization team. We are a centralized team within product development, and support every part of the business, so Miro can reach its global growth objectives. A few months ago, I started to lead an initiative called Experience Foundations.Next, this project is meant to embed localization, accessibility, content design, and design system in everything Miro builds, by default.
This article covers why and how we built it, what the early numbers say, and what we got wrong along the way.
Collaborative AI Workflows
Join thousands of teams using Miro to build the right thing, faster.
Four teams, one engine
We are four teams that contribute to creating a seamless experience for our users.
The initiative came from a shared understanding that only together, when we work as intended, we would be able to provide this experience for our users. What good comes from having consistent design patterns if they're not localized for our global users, or if an assistive technology user can’t use the product?
This is why we banded together to build what we call our Experience Foundations “engine”. We acted in response to all of our fields needing to change how we show up in the product development process, given that designing and building at Miro had dramatically changed with the introduction of AI tools. We saw this as an opportunity to use one framework that would also allow us to easily scale and avoid duplicate efforts.
Three goals that make "by default" concrete
"Embed by default" sounds nice and vague, but you can really think about it as three goals:
- Prototypes built in Vibelab (Miro’s internally built design platform) comply with Experience Foundations design considerations from the start.
- Any experience built for users should be compliant before committing code.
- Miro releases are enterprise-ready with minimal overhead.
The solution we landed on is composed of four pillars. The idea is to influence AI tools as much as possible when teams generate new prototypes or code with our Experience Foundations considerations. The framework has the proper guardrails in place to deterministically catch issues that may have been introduced or forgotten without slowing teams down, and bring visibility to the issues that were identified by humans to the teams releasing early enough within the release cycle, and avoid delays so we don't compromise our Enterprise commitments.
The pillars can be seen below:
The pillars
Pillar | What it does | Where it runs |
Aura MCP and skills | Gives AI agents the right context at the right place and time | In projects where people prototype and build |
Guardrails and self-healing | Checks every new pull request against each domain's standards and suggests fixes | In CI, inside GitHub |
Human in the loop | Finds what AI and automation missed and feeds the findings to be used upstream to refine the engine | Before public beta |
Iteration platform Enterprise readiness | Syncs reported issues from the Human in the Loop step into the iteration platform so teams see them | The Iteration Platform, the one and only place teams can release new capabilities at Miro |
Pillar one: give AI agents the right context before they generate anything
An AI agent can't follow rules it has never seen, which is why we built the Aura MCP, our Model Context Protocol setup, and a set of skills. The Aura MCP holds all the context we would want AI to have in terms of what it means to do localization, accessibility, design system, and content design at Miro. We also created normative rules that we call standards, by domain, with each level of severity and other metadata, such as where they are applicable within the Miro platform.
A few examples of these standards are:
- Localization: never create strings by use of concatenation
- Accessibility: all text needs to meet the minimum contrast ratios against what’s actually behind it
- Content Design: product copy must use sentence case
- Design System: only icons that come from the Design System library should be used across

We also created two sets of skills. The first is our Aura Builder Skill, it reinforces the use of the MCP and standards when it picks up the intent of the developer or designer working on a new user experience. The second is the Aura Audit Skill, it uses the list of standards we’ve defined across our domains and checks what is generated against the rules, and provides a report on what should be fixed by severity.
All of this work happens while AI is being used, so we influence the output as it takes shape. Influence isn't a guarantee, though, and that's why we need the proper guardrails in place.
Pillar two: check every pull request, then offer the fix
Great, so now we have the Aura MCP and skills being invoked when designers, engineers, or product managers are building new experiences with their AI agents. But, how do we confidently ensure that our Experience Foundations requirements were indeed embedded? This is why we built the Aura Bot.
The Aura bot runs in CI, triggered whenever a new pull request is opened. It checks the code against our domain's standards and posts a report if it finds violations across any of the standards, and if so, leaves a comment of what it found directly in the PR with the indicated severity. Within the first week of release and with no obligations, we saw that 41% of issues that the Aura Bot was flagging were organically resolved by those who raised the PRs – that’s 41% less of issues that were getting to our users. This alone has been a great indicator of the strong return on our investment.
We also included a way for the person who raised the PR to give us feedback in case the Aura Bot misread the code, if the standard, for whatever reason, did not apply, or if it was a deliberate exception. Since the release, only 3% of the issues that the Aura Bot flags have been false positives.

But we didn’t want to stop at just sharing a report of the outstanding issues on the raised PR. We took it a step further and recently introduced the ability to provide automated fix suggestions, so we can avoid slowing teams down with a proactive solution. We’re confident that this will help increase our resolve rate of the issues the bot finds.
Pillar three: check what the automation missed
Most of the development effort of this initiative has been focused on the first two pillars mentioned above. We lean on AI and automation to do most of the heavy lifting of embedding our Experience Foundations. And we know that things will still slip through, which is why we formalized the human-in-the-loop pillar to keep a pulse on how well our AI and automation were doing their job.
The human-in-the-loop pillar is a framework that each team uses to review customer releases before public beta through their own respective lens. In other words, it’s a manual QA step. The framework creates a deliberate process for each domain to fully audit ‘ready to ship’ experiences. Aside from what each domain catches and flags to feature teams, we run trend analysis on the issues caught and use this to tweak our AI and automated pillars upstream, to continuously reduce leakage.
Pillar four: make the last gate visible
This last pillar has allowed us to bring the right level of influence all the way through the release process at Miro. We built a Jira proxy microservice to sync the issues found in the human-in-the-loop step to where Mironeers release new capabilities: the Iteration Platform. This new integration brings an unprecedented level of visibility to any outstanding issues to teams before releases, helping them plan effectively so there are no delays, and at the same time, it allows us to uphold our commitments to our Enterprise customers with more confidence.
Lesson one: we built the context, and nobody received it
There are a few lessons we learned along the way, and the first one hit hard. One of the key objectives of the initiative was to influence what was being designed and built by default, meaning, we didn’t want devs or designers to have to jump through any hoops or need to install a secret plugin as a prerequisite to access our Aura MCP and skills. However, we learned through a series of internal interviews that this would be much harder to accomplish than we had originally thought. We invested a lot of time in making our context available, but it wasn't getting used by our internal teams.
The reason was our original context distribution strategy. We had relied too heavily on third-party tools to distribute it for us, and given the wide range of team setups, it was very difficult to ensure consistent coverage.
In our journey to resolve this, we ran many proofs of concept. We tested different methods and measured the output against several requirements that needed to be true in order for our objective of ‘by default’ to succeed. Those hard requirements were:
- No setup for the person. Someone working in a repository we support gets Aura without installing, configuring, or knowing anything, and without depending on a tool that is not on every machine.
- Independent of where the agent is started. The setup keeps working when the agent is opened elsewhere and later pointed at the repository.
- Scoped to the work, not the machine. It reaches only the projects that build production UI, so people who are not building UI pay nothing for it, and within a project brings only what adds value there, so a project that needs some domains does not receive the others, and a prototype receives only the basics.
- Reliable distribution. What we publish reaches every machine the same way and in a known time, the same steps give the same result everywhere, it does not break or go stale by itself, and recovery is a step we can describe rather than a reinstall.
- One source of truth. Content is written and maintained in one place, and every channel reads from it, with no copies in repositories or on machines that can get out of sync or be edited on their own.
- Our voice on our domains. In the repositories we support, no other skill or instruction contradicts Aura, overlaps are visible and reviewed by us, and changes to what we distribute go through our review, not only a generic quality check.
- Visible from our side. We can tell that Aura is installed and whether it is used, without asking the person or needing their permission on every call. At a minimum, the part on our servers reports enough to judge adoption.
- Survives the tools changing. It works the same for Claude Code, Cursor, Codex, and the next agent people adopt, with as little vendor-specific surface as possible.
- Extends to the next repository. Adding the website, a UI microservice, or a template is a small, repeatable change, not a new mechanism per repository or a manual copy of skills.
To achieve this, we landed on using MCP query parameters to allow for content per repo customization, with the added benefit of letting us filter tools and documentation at connection time, before anything else is called. We also moved our skills to static markdown files hosted per repository and used the Aura bot to handle the distribution of syncing updates on an automated basis.
Lesson two: our design template was too strict, killing adoption
Designers at Miro prototype in Vibelab, which is why we wanted to influence designs while they still take shape there. So we created the MDS template in Vibelab, short for Miro Design System template. The template uses our design system components and tokens, and it recreates the look and feel of Miro as a workable prototype. The idea is that any designer who prototypes a new experience from this template starts from a sound foundation, already compliant with our experience foundations design considerations baked in the template’s agents.md file.
We quickly learned through interviews with designers that the template that was meant to help them prototype faster, with baked-in quality, was doing the opposite: the MDS template was too constraining in the early phases of prototyping. Designers didn’t want to fetch all of the rules when just sketching early ideas. Because of this, the adoption of the MDS template suffered.
That feedback was incredibly useful because it showed us where our design considerations should come in: only when a prototype reaches the point where the designer knows they're handing it over for development.
So we made the template much lighter, with far fewer design rules, and saw adoption skyrocket after that change. Now we're building a handover skill for Vibelab, which can describe prototypes, so developers have all the context they and their agents need to build. This is where we want our Experience Foundations design considerations plugged in. This way, we only intervene when we know we absolutely should, when a prototype reaches a polished state, and the designer is ready to build it in Miro.

Lesson three: there’s a thin line between being helpful vs intrusive
We first thought we should influence everything as hard as we could while AI generated it. In hindsight, we were annoying everyone.
Picture a designer or engineer sketching a plan for a brand-new concept while an agent nudges them about compliance. It made no sense, and we heard that loud and clear.
The stakes are real here. Anyone can tell their agent to stop using the Aura MCP, and we would never want that. So the trickiest question has been where to show up in the workflow, and how strongly. We want to influence people at the right level, without being too forceful in the early stages of design and building, and without slowing teams down. We keep listening to our internal users, and that won't change.
One engine can serve four specialist teams
Building this showed me how much one system can do. It can deliver the same outcome for several teams that work horizontally and share the same internal users. We took a systems design approach: one framework that plugs into different domains, each with its own niche expertise. It was the first time I saw that we could build one engine that solves problems for all of these teams, and that their combined expertise adds up to better experiences for users.
What comes next
This initiative isn't finished, but the return on investment looks good so far, and we've heard positive feedback from teams.