A design system fixes accessibility once, if it's the only source

Do accessibility remediation long enough and you arrive at the same conclusion every time. Stop fixing instances. Fix the thing that generates them.

The natural end of that logic is the design system. Fix the button component once, and every button in the product inherits the fix. One change, every instance. It's the most leveraged accessibility work you can do.

It also rests on an assumption that can quietly fail.

"Fixed at the source" assumes there is one source

When you fix the component, you fix every instance that goes through the component. That's the promise, and it's real.

But somewhere in the codebase there may be two or three buttons that don't go through it. A div with a click handler someone wrote in a hurry. A one-off in a corner of the app the component never reached. A copy made before the component existed and was never migrated.

The canonical component gets corrected. The hand-rolled copies don't, because they were never using the source.

So your fix at the source covers the instances that use it and misses the ones that bypass it. The re-audit passes on the pages built from the component and fails on the pages that reinvented it. Same fix, same product, different result, and nothing in the component diff tells you why.

The closing step isn't diffing the component

It's grepping the pattern.

The real end of a source-level fix isn't confirming the component is right. It's searching the codebase for every place the pattern was reimplemented, and deciding, for each one, whether to fold it back into the component or fix it where it sits.

A source-level fix isn't done when the source is right. It's done when nothing bypasses it.

This is the real argument for design systems, and the real work of one

A design system is the honest answer to "fix the system, not the instance." It's the one place an accessible pattern can live so that using it is the default.

But a design system isn't a folder of accessible components. It's a commitment that the accessible pattern is the canonical path, and the easiest one.

Those two conditions carry all the weight. If the accessible menu is harder to adopt than hand-rolling a dropdown, people hand-roll the dropdown, and you are back to instances, now scattered across a codebase that looks like it has a design system. The component exists. It just isn't the source.

So it's two disciplines, not one

Building the pattern accessibly is the part everyone pictures. It's also the smaller part.

Making it the single source is the work. That means making it the path of least resistance, so bypassing it is harder than adopting it. It means catching the reinventions in code review, before they become the copies nobody knows about. And it means, every so often, grepping for the pattern and folding the strays back in.

An accessible component fixes every instance that uses it.

The work is making sure every instance uses it.