Book a call

WritingAI-ready design systemsPart 20 of 20 in Making your design system AI-ready

How do you prove the ROI of an AI-ready design system?

Leadership asks what it costs, what you get and when. A model you can defend with your own data: where the value comes from, how to measure a baseline, a worked payback example, ranges instead of promises, and a one-page business case.

Diagram: off-system rate falling from 60% to 15% after AI-readiness work, converted into hours saved and a payback line crossing zero at about six months.
On this pageThe problem: "Why should we invest in this?"
  1. The problem: "Why should we invest in this?"
  2. Where the value actually comes from
  3. Step 1: measure a baseline before changing anything
  4. Step 2: a simple model
  5. Step 3: present a range, not a point
  6. Step 4: attribute honestly
  7. Leading and lagging indicators
  8. A one-page business case template
  9. Common mistakes
  10. The series in twenty lines
  11. The short version
  12. Frequently asked questions
  13. Further reading

The short answer

Prove it with your own before-and-after numbers, not industry claims. The value of an AI-ready design system comes mainly from less rework on agent-built UI (fewer off-system screens to fix), faster review (fewer design system comments per pull request), fewer accessibility and consistency defects reaching production, and prototypes that become production code with less rebuilding. Measure a baseline with the eval tasks and pull-request data you already have, make the changes, measure again, and convert the difference into hours with a simple model. Compare that with the cost: mostly people's time, plus tools. Present it as a range with your assumptions visible. A defensible, modest number persuades leadership more than a dramatic one.

  • The first evidence is cheap: rerun three tasks before and after an AGENTS.md and a few lint rules.
  • Separate what your work changed from what a new model version changed: run both against the same tasks.
  • Part 20 of 20 in the series on AI-ready design systems.

The problem: "Why should we invest in this?"

Design system teams are good at explaining why AI-readiness matters to other designers and engineers. Leadership asks a different question: what does it cost, what do we get, and when? Answers like "agents will be 10× faster" or "everyone is doing it" don't survive a finance review. This article gives you a model you can defend, using numbers from your own teams. It builds on our general design system ROI model, which is worth reading first.

Where the value actually comes from

ValueWhat changesHow to measure itStrength of evidence
Less reworkFewer agent-built screens need fixing for off-system components, tokens or variantsEval pass rates; fix time per off-system taskStrong: directly measurable
Faster reviewFewer "use the system component" comments; less back-and-forthDesign-system-related review comments per PR; time to approveGood: from PR data
Fewer defectsFewer accessibility and consistency bugs reach QA or productionBug counts tagged "a11y" or "design system", before and afterGood over a quarter or more
Prototype reusePrototypes built from real components need less rebuildingShare of prototype code kept in production; rebuild timeModerate: harder to attribute
Faster migrationCodemods and agents with clear rules move legacy code fasterDeprecated usage over time; engineer hours per migrated screenGood, if tracked
Design system team leverageFewer repeated questions; gaps reported by agents arrive specific and earlySupport questions per month; time to triage requestsModerate
Lead with the first two: they're measurable within weeks and hard to argue with.

Step 1: measure a baseline before changing anything

Every number in your business case depends on knowing where you started. Most of this data already exists.

  1. Eval tasks

    Run 10–15 real UI tasks with your teams' agent, several times each, and score them: lint and type pass, expected components used, raw values, deprecated imports (part 9). This gives you an off-system rate.

  2. Fix time

    For a handful of off-system results, time how long an engineer takes to bring them on-system. This gives you minutes per fix.

  3. Volume

    Estimate how many UI tasks per month are done with agents. Ask teams, or count pull requests labelled "ai-assisted" (part 18).

  4. Review data

    Sample 30 recent UI pull requests and count design-system-related review comments and review rounds.

  5. Defects

    Count accessibility and design consistency bugs from the last quarter.

Step 2: a simple model

Keep the model small enough to explain on one slide. The core is rework avoided:

rework hours saved per month =
    agent UI tasks per month
  × (off-system rate before − off-system rate after)
  × fix time per off-system task (hours)

review hours saved per month =
    UI pull requests per month
  × review minutes saved per PR ÷ 60

monthly value = (rework hours + review hours) × loaded hourly cost
payback (months) = one-time cost ÷ (monthly value − monthly running cost)

An illustration: Harbor's business case

InputValueSource
Agent UI tasks per month400Team survey, checked against labelled PRs
Off-system rate before → after60% → 15%Eval runs before the work and after phase 3
Fix time per off-system task25 minutesTimed on 12 samples
UI pull requests per month220Repository data
Review time saved per PR5 minutesFewer design system comments and rounds, sampled
Loaded hourly cost$60Finance's figure
One-time cost12 person-weeks ≈ 480 hours ≈ $28,800Plan in part 10
Running cost8 hours per month ≈ $480Upkeep of rules, metadata, evals
Illustration Every number is made up for the example. Replace each with your own and keep the source column; it's what makes the case credible.
75 hRework saved per month: 400 × 45% × 25 min
18 hReview time saved per month: 220 × 5 min
$5,580Monthly value at $60 an hour (93 hours)
~6 monthsPayback: $28,800 ÷ ($5,580 − $480)

Notice what's not in the model: defects avoided, prototype reuse, faster migration, the team's leverage. Leave them out of the headline number and list them as additional, unquantified benefits. That keeps the case conservative, which makes it more believable. If you'd like to model the wider design system alongside this, the ROI calculator in the Lab uses the same approach.

Step 3: present a range, not a point

Every input is an estimate. Show what happens if you're wrong.

ScenarioOff-system rate afterTasks per monthMonthly valuePayback
Cautious30%250~$3,000~12 months
Expected15%400~$5,600~6 months
Optimistic10%600~$8,600~4 months
Illustration Approximate, using the formulas above with review savings held constant. If even the cautious case pays back within a year, say so; that's your strongest argument.

Step 4: attribute honestly

AI tools improve every few months. If results improve, leadership will reasonably ask how much came from your work and how much from a better model. Answer it before they ask:

  • Run the same eval tasks with the old setup and the new model. The difference between "new model, old system" and "new model, new system" is your contribution.
  • Change one thing at a time where you can, and record which change moved which number.
  • Keep a held-out set of tasks you never tune against, so improvements aren't just teaching to the test.
  • Report the parts that didn't improve. It makes the parts that did more believable.

Leading and lagging indicators

Some benefits take a quarter to show up. Give leadership something to watch in the meantime.

LEADING · WEEKS

Shows the work is landing

  • Eval pass rate
  • Repos with the AGENTS.md section
  • Semantic tokens with descriptions
  • Components with metadata
  • Deprecated imports per week
LAGGING · QUARTERS

Shows the outcome

  • Rework hours per month
  • Review comments per UI pull request
  • Accessibility and consistency defects
  • Share of UI imports from the system
  • Team survey: trust in agent output

More on choosing measures in design system metrics.

A one-page business case template

# Making Harbor AI-ready: business case

## The problem (with our numbers)
- 60% of agent-built UI tasks need fixing to match Harbor (eval, 15 tasks × 4 runs).
- Each fix takes about 25 minutes. About 400 tasks a month use agents.
- Design system comments appear in 1 in 3 UI pull requests.

## The proposal
Phases 0–3 of the plan (12 weeks, ~12 person-weeks): rules files, token
descriptions, component metadata, an MCP server, lint rules, monthly evals.

## Expected value (cautious / expected / optimistic)
~$3,000 / ~$5,600 / ~$8,600 per month. Payback in ~12 / ~6 / ~4 months.
Not counted: fewer accessibility defects, faster migration, prototype reuse.

## How we'll know
Eval pass rate monthly; review comments per UI PR quarterly; defects quarterly.
Checkpoint at week 6: if the eval pass rate hasn't improved, we stop and review.

## The ask
Two engineers at 50% and one designer at 40% for 12 weeks.
Tip

The checkpoint line matters more than it looks. Offering a point where you'll stop if it isn't working makes the investment easier to approve, and the early phases (rules files, lint) usually show results by then.

Common mistakes

MISTAKE

Quoting industry productivity claims

"Teams are 55% faster with AI" invites the question "which teams, measured how?". Use your own numbers.

MISTAKE

Counting every benefit

A model with eight value streams looks inflated. Lead with two you can measure; list the rest.

MISTAKE

No baseline

Without a before measurement, every improvement is an opinion. Measure first, even roughly.

MISTAKE

Forgetting running costs

Rules, metadata and evals need upkeep. Include a monthly cost; it makes the payback honest.

The series in twenty lines

That's the end of the series. If you've read it in order, you've gone from what an AI-ready design system is to how to fund one. One line per part, to come back to:

PartThe one thing to remember
1Agents amplify whatever your system already is.
2Agents copy what they find first; control what they find.
3Describe every semantic token: use for, not for, use instead.
4Types say what's allowed; metadata says what's right.
5Every docs section must make sense on its own.
6A short rules file in every repo is the cheapest big win.
7A few task-shaped, read-only tools beat searching files.
8Variables and Code Connect turn Figma into real components.
9Lint messages are instructions agents follow.
10One source of truth before many doors.
11Diagnose from the transcript before fixing anything.
12A short map every time; detail on demand.
13Make accessibility a property of components, not prompts.
14One side edited, the other generated, and a drift check.
15Prototyping tools need your code and your guidelines.
16Make your system readable before considering a rebuild.
17Most agent mistakes are unwritten design decisions.
18Whoever owns a decision for people owns it for agents.
19Anything an agent reads is an input; review it.
20Prove value with your own before-and-after numbers.

The short version

  • Value comes mainly from less rework and faster review; both are measurable within weeks.
  • Measure a baseline first: eval pass rate, fix time, volume, review comments, defects.
  • Use a small model: rework hours plus review hours, times hourly cost, against one-time and running costs.
  • Present cautious, expected and optimistic cases, with sources for every input.
  • Separate your work's effect from model improvements by running the same tasks both ways.

Back to the start: What is an AI-ready design system?, or see all twenty parts on the course page.

Frequently asked questions

What is the ROI of making a design system AI-ready?

It depends on your volume of agent-built UI and how often it needs fixing today. The main value is less rework and faster review. Measure your own off-system rate and fix time before and after, convert the difference into hours, and compare with the effort involved.

How do I measure the impact of AI on a design system?

Run a fixed set of real UI tasks with agents before and after changes and score them, track design-system-related review comments per pull request, and count accessibility and consistency defects over time.

How long does it take to see a return?

Early changes such as a rules file, token descriptions and lint rules usually show measurable improvement within weeks. Payback on a full programme depends on volume; modelling cautious, expected and optimistic cases gives a defensible range.

How do I separate our improvements from better AI models?

Run the same evaluation tasks with the new model against both the old and new setup. The difference between them is your contribution. Keep some tasks aside that you never tune against.

What should a business case for an AI-ready design system include?

The problem in your own numbers, the proposed work and cost, expected value as a range, the measures you'll track, a checkpoint where you'd stop if it isn't working, and the specific people and time you need.

Further reading