Reading · The Design System Guide

This page did not load. You can still read it on the original site — the toolbar below keeps your place in the directory.

👋 Get weekly insights, tools, and templates to help you build and scale design systems. More: Design Tokens Mastery Course / YouTube / My Linkedin

If you’re anything like me, you’re tired of the same recycled advice about design system teams.

“Hire a design systems engineer.” “You need a dedicated team of 5.” “Document everything.” The playbooks written in 2022 still get passed around as gospel, even though the world shifted A LOT.

The “right” team size changed dramatically in the past two years. What required 3 people in 2023 can now often be done by 1 person with the right AI toolkit. And what required a much larger enterprise org can now often be done by a smaller, senior team. Well, if the whole delivery system evolves (review, testing, release), not just “writing code.”

But here’s the uncomfortable part: the landscape now changes almost weekly.

New AI capabilities drop constantly. Claude gets better. Cursor ships new features. MCP servers unlock new integrations. What was impossible 6 months ago becomes trivial this month.

This creates a paralyzing question I hear from every design system team: when does it make sense to invest in upskilling?

Most teams are stuck in this loop:

“We should probably learn these AI tools properly.”
“We should create our own LLM.”
“But what if everything changes again next month?”
“The time investment feels bigger than the payoff.”
“Let’s wait until things stabilize.” 🫠

The problem? Things won’t stabilize.

The teams waiting for the “right time” are falling further behind those that have accepted that continuous learning is now part of the job.

The ROI calculation has flipped. The question isn’t “is it worth the investment?” It’s “can you afford NOT to, when your competitors are shipping 2-3x faster?”

This isn’t about replacing humans. It’s about understanding which roles become MORE important with AI, and which tasks you can delegate to AI tools.

I want to share 5 ideas on design system team structure that challenge the conventional wisdom and actually reflect reality in 2026.

Let’s begin.

The cheat sheet: company size → team structure

You aren’t struggling with headcount. You’re struggling with leverage.

Most design system leads I talk to have the same complaint: “We need more people.”

But when I dig into how they spend their time, I find the same pattern. Senior engineers writing documentation. Designers are manually auditing token usage. Leads are drowning in Slack support requests while their roadmap collects dust.

They don’t have a headcount problem. They have a leverage problem.

The reality is that design system work falls into two categories: work that requires human judgment and work that doesn’t.

Human judgment work:

Deciding which components to build next
Designing APIs that will scale
Building relationships with product teams
Navigating organizational politics
Solving novel accessibility challenges

Non-judgment work:

Writing the first draft of documentation
Scaffolding component boilerplate
Auditing tokens for consistency
Generating changelogs from commits
Triaging support tickets

In 2023, we had to do both categories ourselves. In 2026, AI handles the second category with minimal oversight.

If you want to scale your design system, you must have the systems that create scale before you add headcount.

Most teams add people first. Then wonder why the output doesn’t double. The new person gets absorbed into the same inefficient workflows. You pay for two people to do what one person with better leverage could accomplish.

I’ve seen 3-person teams outperform 10-person teams. Not because they worked harder. Because they understood which work to automate, which to delegate, and which to own.

The team of 10? They had more hands, but every hand was doing low-leverage work.

The traditional team models are obsolete. Here’s what replaced them.

The 1-person design system team (2026 edition)

You’re alone. You have to:

Design components in Figma
Build them in code
Write documentation
Evangelize adoption
Handle support requests
Maintain governance
Plan the roadmap

In 2023, this was nearly impossible to do well. Something always suffered (usually documentation and adoption).

But even with AI, there’s a ceiling. One person cannot:

Build deep relationships across 10+ product teams
Ship major components AND do adoption evangelism simultaneously
Handle a design system used by 100+ developers

AI extends your reach. It doesn’t give you infinite capacity.

Warning: The 1-person + AI model only works if...

This model is compelling, but it’s easy to dangerously over-generalize. It only works under specific conditions:

Senior-level experience
You’ve shipped design systems before. You know what good looks like. AI can’t replace the judgment you’ve built over years.
Organizational trust
Leadership gives you autonomy to make decisions without endless approval cycles. If every component needs a committee, AI won’t save you.
Product maturity
Your company’s product patterns are relatively stable. If requirements change weekly, you’ll spend all your time on context-switching, not leveraging AI.
Technical foundation
You can set up your own tooling. If you need someone else to configure CI/CD, MCP servers, or AI integrations, this model breaks down.
Scope discipline
You can say “no” to requests. One person + AI can maintain 20-40 components well. Trying to maintain 100 components solo is a path to burnout.

Red flags this model won’t work:

Your org expects a “design system team” to also run the component library, documentation site, design ops, AND Figma governance
You’re expected to support 5+ product teams with conflicting priorities, design changes, endless meetings, etc.
There’s no executive sponsor who shields you from scope creep
You’re junior/mid-level and still building core design system skills

If you don’t have these prerequisites, push for a 3-person team before accepting the solo + AI role.

The 3-person model

The 3-person model (2023):

Design Systems Lead (Figma, design decisions, documentation)
Design System Engineer (code, CI/CD, tooling)
Product/Ops (roadmap, adoption, support)

This made sense when each domain required full-time effort. Documentation alone could consume 30% of someone’s week.

The 3-person model (2026):

Design Systems Lead (strategy, governance, adoption – 60% strategic, 40% hands-on)
Design Systems Engineer (components, CI/CD, AI tooling, MCP servers)
Design Engineer (Figma library, design-to-code, prototyping, documentation)

Every team member needs these AI-era skills:

Prompt engineering basics: Writing effective prompts for consistent output
AI orchestration: Knowing which tool to use for which task
Quality control mindset: AI output requires review; knowing what to check
MCP/API literacy: Understanding how to connect AI to your systems

Traditional → now handled by:

Documentation writing → AI-assisted, owned by whoever builds the component

Support ticket responses → AI triage + templates, minimal human time

Changelog maintenance → Automated from commits

Usage analytics reports → Dashboards + MCP servers querying data

Contribution process → Templated workflows, AI-assisted code review

The real question isn’t “how many people?” anymore. It’s “how many people doing WHAT?”

What a 3-person team can realistically achieve with AI augmentation in 2026:

50-100 components maintained
Support for a few product teams
Bi-weekly release cadence
Comprehensive documentation (AI-assisted)
Basic design token automation
Visual regression testing
Accessibility compliance monitoring

The 10-person design system team (2026 edition)

At 10 people, you’re running what’s essentially an internal product. The challenge shifts from “can we build it?” to “can we coordinate it?”

Most 10-person design system teams fail not because they lack talent. They fail because they lack clarity.

Nobody knows who decides what
Design and engineering work in parallel silos
Governance becomes bureaucratic gatekeeping
AI tools are used inconsistently (or not at all)
No change log (or decisions log)

Here’s what the optimal 10-person team looks like in 2026:

Strategic Layer (3 people):

Director: Exec alignment, strategy, vision
Product Manager: Roadmap, metrics, prioritization
Adoption Lead: Evangelism, training, support relationships

Design Layer (2-3 people):

Lead Designer: Architecture, governance
Design Engineer: Figma + Code, prototyping
Visual Designer (optional): Multi-brand systems

Engineering Layer (3-4 people):

Engineering Manager: Architecture, code quality
Platform Engineer: AI infra, CI/CD, MCP servers
Frontend Engineers (x2): Components, features

Specialized (1-2 people):

Accessibility Specialist: Compliance, auditing, training
Developer Experience (optional): Docs, AI tooling, prompt libraries

The hiring signals that actually matter

Don’t hire based on company size. Hire based on these signals:

You’re spending more than 50% of time on support and maintenance
Adoption has stalled because you can’t do outreach
You have a backlog of 6+ months of component requests
Teams are building workarounds because they can’t wait for you
You’re burning out

The skills that became MORE valuable

Own these:

Strategic decisions: Which components to build next
Design quality: Ensuring components solve real problems
Relationship building: Getting teams to actually adopt the system
Governance frameworks: Setting the rules (even if AI helps enforce them)
Complex problem-solving: Edge cases, accessibility nuances, cross-platform considerations

Delegate to AI:

First drafts of documentation
Code scaffolding and boilerplate
Token validation and linting
Changelog and release notes
Support ticket triage and initial responses

Delegate to product teams (with good tooling):

Basic component usage
Bug reports with clear templates
Contribution of simple patterns

Roles that are becoming MORE important in 2026:

1. Adoption Lead

AI can generate components. It can write documentation. It can even respond to support tickets.

What AI cannot do is convince a skeptical product team to use your system instead of their custom solution. It cannot navigate the politics of a reorg. It cannot sit in a room and understand why adoption stalled.

The companies winning at design systems in 2026 have someone dedicated to this. Not as a side responsibility. As the main job.

2. Platform Engineer

Someone needs to set up and maintain the AI infrastructure. MCP servers. Automation pipelines. The tooling that lets AI access your design system data.

Most teams underinvest here. They use AI tools but don’t customize them for their context. They get generic outputs because they provide generic inputs.

3. Accessibility Specialist

AI catches basic accessibility issues. It can run automated scans and flag obvious violations.

But accessibility at scale requires human expertise for edge cases, cultural considerations, and training teams to think accessibly from the start. This role became more important, not less.

4. Developer Experience Engineer

With AI-assisted development, the quality of your AI tooling setup directly impacts productivity. The prompts. The context. The MCP configurations.

This role didn’t exist in 2023. In 2026, it’s a competitive advantage.

Roles that shrunk or merged:

1. Technical Writer (as a standalone role)

Documentation is now AI-assisted and owned by builders, not a separate function. The writer role evolved into “documentation architect” – someone who designs the structure and reviews AI output.

2. Junior Developers

AI handles much of what junior devs used to do. Copy-paste patterns. Boilerplate scaffolding. Basic component implementation.

Fewer junior roles, but those who remain need AI collaboration skills. The junior dev of 2026 is more like the mid-level dev of 2020.

3. Pure Visual Designers

Design engineers who can implement are more valuable than designers who only produce Figma files.

The 2026 Formula

Fewer people + Higher seniority + AI augmentation = Same or better output

A 1-person team with AI beats a 1-person team without.
A 3-person team with clear roles beats a 5-person team with unclear ownership.
A 10-person team with defined accountability beats a 15-person team playing politics.

Your design system team structure isn’t about hitting a magic number. It’s about:

Understanding what AI changed
Investing in the right roles
Matching structure to stage
Watching the signals

Start by auditing your current team against these models. What’s your biggest gap?

That’s where you either hire or leverage AI.

I’ve gathered more articles below, if you want to dig in to numbers or experiences from other companies.

Stay tuned and enjoy the process,

Romina

💎 Community Gems

Hackathon

February 6-8 2026 - Online

I am part of the jury and will also help you to hack faster ;) See you there. 😊

🔗 Link

— If you enjoyed this post, please tap the Like button below 💛 This helps me see what you want to read. Thank you.

Want more actionable insights like this? Subscribe & never miss a post! ❤️

Design systems team structure in 2026