I turned my biggest design system headache into my first Cursor command
How revisiting an old project became an experiment with AI and the beginning of learning where it fits into my work.
If you read my previous post, you know a pattern project once haunted me for a very long time. Long enough that it became my first try at creating a Cursor command.
Where this started
Two things inspired me.
The first was a post from Jesse Gardner, who used AI to build an entire interaction pattern library for the NYS Design System (impressive!!!). He took screenshots of the identified patterns and added them to a board for designers to review and refine in a real feedback loop. Designers were actually helping shape the system. The exact part I'd missed when trying to "save everyone's precious time."
The second was one of our product designers, who created a bunch of commands (me, immediately: GPT, what are Cursor commands?), such as cleaning the workspace or starting a prototype using our design system.
At the time, we were all new to Cursor. I had no idea what commands were capable of, or even what they were, for that matter. It just felt like the sky was the limit.
So I combined these two inspirations and decided to build my first command.
I wrote what I needed in plain language: what to look for, how to behave, what a designer would actually need from it, and asked Cursor to turn that into a working command.
Making it usable
The first version worked, but it needed some more love.
I redefined three questions that it should ask before scanning anything:
What pattern am I looking for?
Which product or area should it scan?
How should the workspace be prepared (save branch, delete, create a new one, etc.)?
From there, it would scan the relevant repos and return an HTML page: a table of everything it found, with links back to the source code, and a gap analysis pointing to undocumented pattern rules, inconsistencies across modules, what’s missing in our design system and recommended standard patterns.
Which, obviously, would require a human to continue the analysis and decision-making.
Putting it to the test
My first test was the status and feedback patterns, the one from “that project that haunted me”. 42 patterns. 41 compliant. An audit that once took weeks now ran in minutes.
My second run focused on a Terms & Conditions flow. It identified eight instances and four different implementations of the same flow (full page, dialogue, wizard step, form), plus an undocumented behaviour: whether terms should open in a new tab or stay in context. It surfaced a decision nobody had officially made.
The third run covered upsell and activation patterns. It found ten instances, including one unexpected case in our own domain: using an error state to indicate “feature not enabled yet,” which is misleading in a conversion context.
Instead of stopping at “what exists”, it also suggested directions based on existing internal implementations.
Not all sunshine and rainbows
I hit an unexpected limitation.
Because our application sits behind authentication, the command could tell me exactly where a pattern lived in the code, but often couldn't show me what it actually looked like. I tried sandboxes and logged-in sessions in the local server, but neither worked really well.
So the solution became a great detective, but a not-so-good photographer. I still had to do some manual work.
(If you’ve solved this, an AI agent reliably screenshotting an authenticated app it can’t log into on its own, I’d love to hear how.)
I can now sleep better
Even with that gap, the time saved was super significant.
And I didn't just build it to prove a point to myself and sleep better. The command actually helped me on real projects.
Months later, when Claude became our official tool, I rebuilt it as a Claude Code skill (picture me, again, asking GPT: what’s the difference between a command and a skill?).
It can now generate Storybook stories for every instance it finds, letting me preview components without logging into the app. Not perfectly, it could still get some more love, but one step closer to what I pictured.
AI can’t solve everything
The story is not about AI fixing everything. It wouldn’t. It can’t.
But it removes the slow, manual part of the work: the hunting, the collecting, the repetition.
Looking back, my main challenge wouldn’t have disappeared. I’d simply have more space and confidence to involve designers more, instead of worrying about wasting their time.
The thing that once took a whole team, a whole quarter, and a board that stayed empty can now start as a simple command.
And instead of waiting months to even begin defining something everyone's been asking for, you can have a real answer in a fraction of the time, and spend the rest of it on the part that actually mattered.
Which means that board would never have stayed empty in the first place. And that haunting feeling wouldn't even have a chance to show up.
If you missed my previous post about the “haunted” project, don’t forget to check it out :)