


It usually starts with a request to help users finish a task faster.
"Can people open it straight from its card? And can they favorite it or share it without leaving the page?" We work out what each click does: click the card to open the item, click the star to save it, click the arrow to see sharing options. Then it ships immediately because of a deadline nobody can quite explain.
Now there's a pattern in our product that blocks people from getting something done. It looks like one thing, but it's unclear what it does. Under the hood, it's a pile of divs and ARIA attributes. That pattern lives in the product for the next few years. Other teams reuse it because it already exists. The data shows users struggling with that exact pattern, but the team has already moved on to the next thing.
We've just built a Frankenstein pattern. Like Victor, we'll spend years running from what we made.

A "Frankenstein pattern" is an anti-pattern that merges too many functions and interaction types into a single pattern, resulting in a design that has unclear affordances. Like Frankenstein's monster, these patterns are assembled from pieces of other components and patterns, usually when we try to solve many needs at once without thinking through the interaction model.
Here are some common contexts in which we encounter Frankenstein patterns:
A few years ago, the usual recipe was a rushed set of static designs in Figma that we handed to an engineer, who built in some framework with an unholy amount of JavaScript. These days, though, more of us are handing the thinking to an LLM, whether by choice or by mandate. LLMs are trained on decades of anti-patterns, perpetuating Frankenstein patterns at a greater scale.
The even bigger problem is that LLMs are sycophantic. A coworker might nudge us to avoid a Frankenstein, but a model rarely does. Ask for a card that's a link, with a favorite toggle and a share button, and a model will try to build it. The monster emerges just the same, only faster, and with even fewer people stopping to ask why we're building it.

Frankenstein patterns start with our decisions, whether we are using AI or not. The only difference now is that we have an Igor to our Victor. Fittingly, Igor never appears in Mary Shelley's novel. The films bolted him on later.
Frankenstein patterns usually start from good intentions: making a task faster and easier for users. The trouble comes in the execution. Each part in a Frankenstein may be easy to use on its own, but combined, their affordances blur or are forgotten. Users are left guessing what the pattern does. They slow down, get stuck, or give up entirely.

Take a card. Cards are one of our most flexible patterns, with no inherent interaction model the way a link has. We made our card a link, but it doesn’t have the affordances a link typically has. Ours is a div with role="link" and a click handler, with favorite and share buttons stuffed inside it. Users now juggle several interactions in one loop space. They may not realize selecting the card will navigate away, and the card's selection area surrounds the other controls, so a tap that just misses the star opens the item instead.
Because it's a div, it only does what someone remembered to script. Assistive technology may announce the card's entire contents as the link name, so screen reader users may sit through all of it, and voice control users have a long, unwieldy name to say. ARIA doesn't allow buttons inside an element with a link role, leaving browsers and assistive technology to guess how to expose them.
Cards turn into Frankenstein patterns easily, but cards themselves aren't the problem. We can still use them if we’re thoughtful in how we design and build cards. If we build a card, or any pattern, without thinking through its purpose and affordances, we've got a Frankenstein.
Working on a design system means I see patterns at scale, often after they've already been copied across a product. Designers and PMs ask whether a pattern will work for their use case. Engineers come mid-build, unsure how it should behave for keyboard or assistive technology users. Many of those questions lead back to a Frankenstein.
This is where accessibility expertise is powerful. At its core, accessibility is the practice of making interactions perceivable, operable, understandable, and robust for as many people as possible, in as many contexts as possible. We can stress-test interfaces against physical, sensory, cognitive, and situational limits, and Frankenstein patterns buckle under that pressure fast.
To avoid building a Frankenstein pattern, start by asking:
Ask these early, before prompting or building. If they're hard to answer, we may be building a Frankenstein.
Once we’ve spotted a Frankenstein, our instinct might be to just patch it: add a tooltip, tack on an ARIA label, write a help article. Resist this urge because patches only keep the monster alive. The real fix usually means stepping back to look at what each piece of the pattern is trying to do, and finding a clearer way to do it.


Think back to our card. It had three main jobs: open the item, favorite it, and share it. Now the title holds the link. The favorite and share buttons are separate, each named for what it does and which recipe it acts on. Every control in the card now does one thing.
When we’ve finished our creation, we need to document the decisions we made. Record why the pattern changed and what it replaced. That way, the next team won't stitch the old one back together, and any LLM working in our system has the reasoning to draw on.
Victor Frankenstein's real failure was building without thinking, then abandoning his creation the moment it came alive. We do the same when we cram too much into one pattern, ship it without checking that it works, and move on.
The fix is to design patterns on purpose, document why they work, govern how they're used, and come back to them. Our creations are ours to look after.
