Gah! AI, I Already F*ing Fixed That!

Teaching AI to Think in Systems

As I invest time and money learning and experimenting with how to get AI to work within the design systems and principles I already understand, I find myself stepping back to ask what I'm actually learning versus what I'm repeatedly having to teach. I know we're all doing some of both as we learn to communicate what's in our heads, establish rules and constraints, provide context, and correct the output when it drifts.

Markdown files, Figma libraries, kits, and other ways of giving AI context and instructions are a great start. But I still find the integration lacking and keep receiving unpredictable results, leaving me wondering: What if the workflow itself helped preserve the decisions?

If you're wrestling with this, too, I'd love to hear where you are, what you're trying, and what workarounds you've found. Let's compare notes, share what we're learning, and maybe save each other some time, AI credits, and sanity. (questions below)

‍

Defining a System

A design system isn't just a collection of visual choices or examples for AI to elaborate on. It's a set of relationships, reusable decisions, constraints, and dependencies that help the pieces work together coherently as the system evolves.

I need AI to respect that system.

How do I get it to follow established patterns rather than invent new ones? How do I preserve the decisions that make a design distinctive rather than watching them dissolve into something generic? How much context do I need to provide, and how much should the tool be able to infer from the system itself?

The obvious place to start has been the humble Markdown file. Put the rules in Claude.md. Create a Guidelines.md file for Figma Make. Break the guidance into smaller files for colors, components, interaction patterns, accessibility, and all those decisions I don't want to have to explain again. Give the AI a map of the system instead of burying everything in one monster prompt.

‍

The tools are getting there. No doubt, they're on it.

Figma already offers several ways to connect AI to design-system knowledge. Make guidelines provide written instructions. Make kits can bring in packages, styles, and variables from published libraries, along with guidance about how to use them. Figma Design also supports guidelines attached to design libraries that can be made available to its agent. Claude has its own ways to work with design systems, including Claude Design and workflows that connect design work with Claude Code. This is not a blank slate, and I don't want to pretend otherwise.

But these capabilities don't all work the same way, and they don't yet amount to one seamless workflow. For example, Figma's library guidelines and Make-kit guidelines are separate workflows; guidelines attached to a published Design library aren't currently carried into a Make kit when the kit is created. And a Make kit's extracted styles are a simplified view of the library's variables, not a complete preservation of the original token structure. These are meaningful distinctions when we're trying to keep the system and the generated work aligned. (As of October 2026.)

A Markdown file can say, “Use an existing color token rather than inventing a new color.” A design library can provide approved colors and components. But neither one, simply by existing, guarantees that every generated screen will follow the rules. Instructions, structured assets, and checks that catch violations each have a role to play.

Designers are still left maintaining the connections between these pieces and correcting AI when the guidance, assets, and requirements no longer agree. Decisions we've already made still have to be repeatedly taught, remembered, and enforced by the designer.

A set of files isn't the whole answer.

‍

How are these pieces working together? How would we like them to?

Although Claude and Figma are already making progress on knowledge reuse, we cannot yet assume that reuse means AI will reliably preserve decisions and relationships as the work evolves.

The goal isn't to feed the entire system into every interaction. It's to make the right knowledge available when it's needed, preserve the decisions that should persist, and check the things that actually need checking. We need tools that can preserve system-wide coherence while bringing only the relevant knowledge into a particular task. Now THAT is a tool worth investing in.

I'd love to see Figma make the ecosystem easier to understand and use: how libraries and kits relate to individual Make sessions, where to store a rule, when it applies, and whether it should become reusable guidance or stay specific to a project. Even when the capability exists, discovering it, adding to it, and knowing what to trust can still be harder than it should be.

There's a difference between giving AI access to a rule and getting it to follow that rule reliably. There's also a difference between documenting a design system and making it usable by AI in a way that preserves the thinking behind it.

Skills, now supported by both Claude and Figma, are Markdown files that teach an agent a team's workflows and conventions. They're great for capturing instructions, principles, and workflows. But they're not a guarantee that AI will follow those instructions consistently. A Skill can tell the machine what the rules are; it can't guarantee that the machine won't violate them a few prompts later.

‍

What if the workflow itself helped preserve the decisions?

I keep coming back to Brad Frost's Atomic Design because it helps clarify how smaller, reusable pieces combine to form more complex structures. Organizing the pieces is one problem; preserving the relationships and design decisions that make the whole system coherent is another.

WHAT IF an AI could retain that system and carry its relationships and rules across different working environments—applying the parts relevant to a specific task without confusing the task with the system itself?

And WHAT IF that came through an integrated workflow: one that lets a designer move in and out of AI tools quickly, choose which changes should be retained in the “system,” and decide which changes are just for the current task, even as deadlines loom?

Maybe the technical solution isn't teaching the machine to remember harder. Maybe it's designing the workflow so the machine doesn't have unilateral permission to reinterpret everything.

One thing I know for sure: I am tired of spending AI credits to fix design decisions I've already made. If I've already established a rule, why am I repeatedly paying—in time, attention, or credits—to get the tool to rediscover it?

‍

Let's compare notes

I'd love to hear how you're approaching this challenge and what you've learned along the way.

• What do you think it will take for AI to work reliably within an evolving design system?
• Where do you see the biggest gaps between what we can do today and what we need?

‍