Design systems . AI Ready
Beyond the prompt
Built for designers, developers, and AI.
I help product teams, PMs, and marketing units build, fix, and evolve scalable design systems, structured with semantic intent so that humans and AI agents can reason with them confidently.
My Approach
Standard DS (Focused Only on UI & User Needs)
❌ What the component looks like
❌ What states it has
❌ How it behaves visually
❌ Tokens out of sync between design and code
❌ Design intent lost in handoff
AI-Ready DS (Empowering the Entire Ecosystem & AI)
For Product Teams: Why this component exists & what problem it solves
For Product Managers & POs: Decision logic, trade-offs, and embedded business rules
For Marketing & Campaigns: Scalable patterns that launch campaigns without breaking brand identity
For Engineers & Vibe Coders: Semantic token relationships that prevent AI code hallucination
For AI Copilots & Agents: Structured context so machines can reason, not just copy
Without intent, AI and humans can only copy with a structured system, everyone—from product owners to campaign teams and AI agents—can reason.
origin
Trained in Milan, where design was never just pixels.
Design school there taught the discipline as a holistic product-service ecosystem, not a screen-by-screen craft. That framing has carried through years of moving from interface design into architecting larger product systems — and it's what makes this moment feel different.
We're no longer designing only for screens. We're designing for an era of copilots, LLMs, agentic workflows, and vibe coding — and most product teams still carry a glaring bottleneck: AI speeds up production, but it quietly breaks systematic intent.
what makes a system AI-ready
I design systems so AI can actually use them.
Most design systems describe appearance. AI needs intent. Here's how I build systems that both humans and machines can reason with.
{
"color": {
"action": {
"primary": {
"default": "#6B4FE8",
"hover": "#5A3FD4"
}
},
"feedback": {
"error": { "default": "#E05A5A" }
}
}
}
// component intent docs
"Button.Primary": {
"purpose": "Main CTA",
"use_when": "1 action per view",
"avoid_when": "Competing actions"
}
01
Semantic naming that communicates hierarchy & intent
Names like color.feedback.error.default tell AI what a token means, not just what color it is. Structure carries meaning.
02
Design tokens that encode meaning, not just values
Tokens aren't just variables. They carry context — role, tier, usage rules — so AI can apply them correctly, not randomly.
03
Components defined by purpose and rules, not only visuals
Every component includes when to use it, when not to, what problem it solves, and what trade-offs were made.
04
Documentation that explains context and decision logic
Not just what the system is, but why decisions were made. AI tools need narrative context, not just specs.
05
Decisions captured where they happen — not buried in chat
Design rationale lives inside the system itself, versioned and retrievable — by humans and AI assistants alike.
what I do
Four ways I help your team.
I don't come in with a fixed recipe. Sometimes strategy, sometimes build, sometimes audit — often a mix. What stays consistent: turning your design system into something teams rely on.
01 — BUILD
Full Service Design System
For teams starting from zero. I design a system that humans and AI tools can both understand — not just how things look, but how they should be used.
02 — FIX
Design System Review
For systems that exist but need to change or upgrade. I evaluate the whole tokens, components, docs, handoff gaps, and give you a clear roadmap on what to fix, keep, and kill.
03 — BRIDGE
Design–Code Integration
For when Figma and code speak different languages. I build workflows where tokens stay aligned, components translate cleanly, and design intent carries through to production.
04 — EVOLVE
Maintenance & Governance
For systems that worked, until your product grew. I keep them healthy through versioning, quality checks, automation, and documentation that stays useful for humans and AI.
3×
Faster design-to-code with token sync
AI
Readable by agents, not just humans
5+
Tools actively used & maintained
what I do
A repeatable process that scales
Whether I’m building a system from scratch or evolving an existing one, I design across the full experience, from foundations and interfaces to AI interactions, with transparency and clarity built in. So the process follows the same arc: understand, structure, implement, sustain.
I design systems where AI doesn’t disappear behind the interface — its role, behavior, and impact are made clear to the people using it.
01
Understand & Audit
I start by understanding how your product, team, and users actually work — including where AI is involved and where its behavior needs to be made clear.
– Evaluate design + code libraries
– Map consistency, reuse & user needs
– Assess accessibility (WCAG) & AI transparency
– Identify design–dev & AI handoff gaps
02
Structure & Design
I turn insights into a system that works for both people and AI — designing the foundations, components, interactions, and documentation that make intent clear.
– Semantic token & component architecture
– Interfaces designed for human + AI use
– Transparent AI interaction patterns
– AI-readable documentation & design rules
03
Sustain & Evolve
Good systems shouldn’t become black boxes. I build governance, feedback, and maintenance into the process so people can understand what the system does — and why.
– Versioning & visible change history
– Contribution rules & governance
– AI behavior, feedback & transparency
– Continuous quality & adoption checks
Figma + MCP
Source of truth for structure & component logic. MCP lets AI validate tokens fast.
Fi
Ts
Token Studio
Defines semantic, scalable design tokens with hierarchy and meaning.
Bi
Builder.io
Stress-tests component flexibility in real layouts — reveals system gaps.
Co
Microsoft Copilot
Speeds up audits, documentation reviews, and accessibility checks.
Cu
Cursor
AI-assisted editor for moving from design system to real code, fast.
Sb
Storybook
Documents and tests coded components. Single source of truth for dev.
Fu
Fusion
Catches inconsistencies early and makes designs code-ready before handoff.
Sd
Style Dictionary
Syncs tokens across design and code without manual translation.
Ly
Lynt Plugin
Catches inconsistencies early and makes designs code-ready before handoff.
Zh
ZeroHeight
Maintains clear, human-friendly documentation that stays up to date.
FAQs
What teams usually ask.
Do you only build new systems, or do you work with existing ones too?
Most projects start with an audit of what's already there rather than a rebuild from scratch. Improving an existing system is often more practical and cost-effective than starting over.
What makes this different from a typical design system setup?
The focus isn't just on designers and developers — the system is built so AI tools and automation can use it too. That means clearer structure, defined meaning for every part, and a workflow that fits today's tooling.
Does this mean AI replaces designers or developers?
No. Repetitive, mechanical work gets handed to AI, but judgment, creativity, and final decisions stay with people. The goal is reducing friction, not replacing expertise.
How deep do you go into the technical/coding side?
Very hands-on. The work involves components, tokens, and development tools directly, so design intent survives all the way to production. Comfortable operating right at the boundary between design and engineering.
What if our team uses different tools?
That's fine. Any tools mentioned are just examples, not requirements. The approach adapts to whatever stack your team already has — what matters is the underlying principles, not a specific tool.
How do you keep the system from becoming rigid and slowing things down over time?
Through clear intent, lightweight (not heavy-handed) governance, and automation. A good system should remove repetitive decisions, not flexibility — and it should grow with the product instead of blocking it.
What's the difference between a design system and a component library?
A design system includes the rules, governance, and design principles; a component library is the coded implementation of the UI pieces themselves. Both are covered in the work.
Is this only useful for large, mature teams?
No — it applies at any scale. Smaller teams often benefit even more, since they can set the right foundation early and avoid painful rewrites down the line.
READY TO START?
Your design system should work for you.
Let's build something your whole team — and your AI tools — can actually rely on.