I've been thinking about what it actually means to finish a design system.
The more I work on one, the less convinced I am that you ever really do.
There is always another component, another pattern, another edge case, another product requirement. And even if you manage to get everything into a good place, the world around the system keeps changing.
Users change, business priorities change, technology changes, even the products themselves change. So perhaps the goal isn't to build a design system that is finished. Perhaps the goal is to build one that can keep going without you.
That thought has led me back to something I've enjoyed for a long time outside of design: world building.
A design system as a living fantasy world
A system needs rules before it can grow
When you build a fictional world, you don't just make a list of characters and places.
You give the world rules. You decide how things work. You establish history. You create relationships. You decide what is possible and what isn't. And then something interesting happens.
Once enough of those decisions exist, you don't have to make every future decision yourself because the world starts to guide you.
If you've established how a society works, introducing a new character means thinking about how that character fits into that society. If you've established a particular technology, introducing something new means thinking about what that technology would affect.
One decision creates consequences somewhere else.
That is exactly what I've started seeing in design systems. A mature design system isn't really a collection of components. It's a world with its own rules.
The architecture of a complex system with the relationships between them.
Eventually, it becomes bigger than the person who built it
This becomes especially interesting when you're building a design system to be used by AI. A mature system could easily end up with 300 or more Markdown files.
That sounds like a lot, but the number itself isn't really the problem. The problem is that those files are connected.
A component is used by a pattern.
That pattern is mentioned in guidance.
That guidance might reference accessibility requirements.
Another component might be an alternative in a particular situation.
A pattern might depend on several components.
A component might have relationships with several other components.
And suddenly, changing one thing can have implications in five, ten or twenty other places.
A human can manage this for a while. You learn the system, remember where things live, you start building a mental map of how everything fits together. But eventually that map gets too big.
Not because you're bad at your job. Just because there is a limit to what one person can reliably remember.
And this is where I think AI can be genuinely useful and it is not because it can make another button, but because it can help keep track of the things we struggle to keep track of ourselves.
And that's supposed to feel a little uncomfortable
If you're a designer building this kind of system, there is an uncomfortable thought that can creep in:
"If I make this smart enough, will they no longer need me?"
It's a perfectly normal fear, especially when you're building something that can identify new components, understand existing patterns, maintain documentation and help keep the system consistent.
If the system can answer questions that previously came to you, update things that previously required your attention and spot problems that previously relied on your memory, it is reasonable to wonder what happens to your role. But I don't think the goal is to make the designer unnecessary.
The goal is to acknowledge the limitations of being human and build something that can overcome them.
A human can only remember so much. We can only hold so many relationships in our heads. We can only manually check so many documents. We can only notice so many dependencies.
At some point, the complexity of the system becomes greater than any one person's ability to reliably keep track of it.
That's not a failure of the designer - it's simply a limitation of the human mind and that's where AI becomes interesting. Not as a replacement for the designer, but as a way of extending what the designer can do.
The designer still makes the judgement. The designer still defines the principles. The designer still decides what the system should become. The designer still needs to understand the users, the business and the technology around it.
The job doesn't change. The context in which that job can be done most effectively does.
Instead of personally remembering every relationship in a system with hundreds of interconnected pieces of knowledge, the designer can work at a level where the system itself helps surface those relationships. Instead of manually checking every document after a change, they can ask: "What does this change affect?"
Instead of spending hours trying to find every place where a new component belongs, they can have the system show them the connections and make the judgement themselves.
The designer hasn't been removed from the process. They've been given a way to operate beyond the limitations of individual human memory and that's what I find most interesting about AI in design systems.
Not that it can do the designer's job, but that it can allow the designer to do the same job at a scale that would otherwise be impossible for one person.
Because no one can remember every connection
Imagine someone proposes a new component.
The easy part is creating it. The harder question is: Where does it belong?
Does it replace something that already exists?
Should it be included in an existing pattern?
Does some existing guidance need to mention it?
Does it introduce a new accessibility consideration?
Are there other components it should be related to?
Does something already documented contradict it?
A human can work through these questions, but when the system gets large enough, it becomes very easy to miss something. This is where I want AI to help.
Imagine being able to ask:
"If we introduce this component, what else needs to change to keep the system accurate and consistent?"
And getting an answer that points you towards all the relevant places.
Not just a list of files. An explanation of the relationships.
"This pattern should reference the new component."
"This guidance currently recommends another component in this situation."
"This accessibility guidance applies to the new component."
"This existing documentation may now be inconsistent."
"These are the things that need to be reviewed."
That's much more interesting to me than AI simply generating UI. The AI isn't making the design decision, it's helping us understand the consequences of the decision.
A new component introduced into a design system and it's possible implications
A design system is a living thing
There is another reason I don't think a design system can ever really be "finished." The world around it doesn't stop changing. User needs change, business goals change, technology changes, new products appear, old products disappear, accessibility expectations evolve, new interaction models become possible.
AI is changing the way products themselves are built.
A design system that was perfect two years ago might be completely wrong for the organisation today and that doesn't mean the system failed. It means the system is doing what living things do.
It needs to adapt.
The goal shouldn't be to build a design system that is eventually complete. It should be to build one that can evolve without having to be rebuilt from scratch.
Evolution of a design system over time
This is another place where world building makes sense to me. A good fictional world doesn't stay frozen. It changes. Characters grow. Power structures shift. New discoveries change what people thought was possible. But the world doesn't have to be rebuilt every time something changes. It has enough internal logic to absorb those changes.
I think design systems need the same quality.
So the system needs a memory of its own
This might actually be the most important part.
Change itself isn't the problem. A design system that never changes will eventually stop being useful. The problem is changing one thing and forgetting the five other things that depended on it. That's how systems slowly become inconsistent.
One page says one thing. Another says something slightly different. A pattern still refers to something that was deprecated six months ago. A component has a new recommended use, but the guidance never got updated.
None of these problems necessarily happen because someone made a bad decision. They happen because the system has become too big for one person to keep entirely in their head.
That's where an AI assistant can become part of the system's memory. It can help find the connections. It can flag the things that might be affected. It can help keep the documentation aligned. And, once a human has confirmed a change, it can take care of the repetitive work of updating the places that need to change.
Because a useful system never stops changing
There is something that sounds almost contradictory about all of this. If you can build a system that applies your thinking when you're not there, aren't you making yourself less necessary?
I actually think the opposite is true. A good design system has always tried to do this. When you define a component, a pattern or a principle, you're taking something that previously lived in your head and making it available to other people. You're effectively saying:
"This is how I think we should solve this problem."
And then you're turning that thinking into something other people can use. AI just takes that idea one step further.
Instead of your thinking being available only to another designer reading your documentation, you can build a system that can apply that thinking when someone encounters a new problem.
It can recognise that something is similar to an existing pattern.
It can identify the principles that apply.
It can explain which constraints matter.
It can point out where a proposed solution conflicts with something the system already knows.
It can even help identify when something genuinely new needs to be added.
That's not the designer disappearing. That's the designer's thinking becoming useful beyond the designer and I think that's actually a much better demonstration of the value of design.
We sometimes measure design by what the designer produces.
The screens.
The components.
The flows.
The documentation.
But perhaps the real value of a designer is what happens after the designer has made the decision. If the system is good, the thinking doesn't stop with the person who had the original idea, it gets embedded into the system, it gets picked up by other designers, it influences engineers, it guides product decisions and increasingly, it can be applied by AI.
The designer doesn't need to be in every conversation for good design decisions to happen. In fact, the number of correct decisions that happen without you in the room might be one of the best measures of whether you built a successful system.
That sounds counter intuitive, but if every decision still needs to come back to you, then perhaps the system hasn't really captured your thinking. You've just become the system.
The better outcome is that the system carries enough of your thinking that other people can make good decisions without having to ask you every time. And now AI gives us the possibility of taking that even further: not just documenting how we think, but creating something that can apply that thinking.
That is a very different kind of self-sufficiency and I think it's one worth designing for.
Designer's thinking being passed on
Self-sufficient doesn't mean autonomous
This is an important distinction for me. I don't want a design system that changes itself without anyone asking. I don't want an AI deciding that something should become a component and quietly adding it. There should still be a human making that call.
What I want is something closer to a very thorough colleague. Someone who says:
"I think this might be new. Here's what I've found that is similar."
"If we add it, these are the places I think it will affect."
"Here are the things that currently conflict with it."
Then the human decides and once the decision is made, the AI can help make sure the rest of the system catches up. That feels much more useful to me than replacing the human decision altogether.
Building something that can survive you
This is where I come back to the original question.
What happens when the person who built the system leaves?
I've been thinking about this partly because I'm working on a design system on a contract. I might not get to do everything I would ideally want to do before the contract ends and that has made me think differently about what "done" should mean.
I don't want to leave behind a system that works because I happen to know how everything fits together. I want to leave behind something that can continue without me, whether I am still working with this company or not.
That means putting the thinking into the system. Not just the components, not just the documentation, but the relationships, the reasons, the rules, the decisions about what is canonical and increasingly, the mechanisms for keeping all of those things connected as the system changes.
Designer being able to walk away from the system while the system maintains the standard of quality
That's probably the biggest thing world building has taught me about design systems. When you create a world, you don't want the world to depend on the author remembering every detail. You want the rules to be strong enough that the world can keep making sense.
I think a design system should aspire to the same thing. It shouldn't need to be finished. It shouldn't need to stay unchanged. And it shouldn't need its original creator to explain it every time something new happens.
It should be able to grow, adapt, absorb new ideas and, when something changes, help you understand what else needs to change with it.
Because perhaps the ultimate sign that you've built a good system isn't that everyone still needs you. It's how many correct decisions can happen without you in the room.
And perhaps the ultimate sign that you've done your job as a designer is that they no longer need specifically you for the work to keep the level of quality high.
Although, I could be wrong. This is one of those ideas I suspect I'll either laugh at in five years...or wish I'd written down sooner.