Frankenstein's pattern: When design system components get stitched together

Anna E. Cook
Written by Anna E. Cook
Oct 29, 2026

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.

An image, a button, a block of text, and two icon buttons stitched together with plus signs over the faint outline of a Frankenstein's monster face, forming one patchwork component.

What is a Frankenstein pattern?

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 selectable card with inline controls that are also selectable.
  • An auto-rotating carousel overlaid with links and buttons.
  • A combobox that also multi-selects, previews on hover, and holds links and buttons.
  • A date picker for single dates, ranges, times, time zones, and relative options.
  • A dialog with a multi-step form that opens another dialog.

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.

Diagram: the request “Build a card that links to a recipe, with favoriting, sharing, and preview 
content for the recipe.” branches to two responses. A coworker, shown as the Tim Robinson meme, asks "You sure about that?" An LLM, shown as the SpongeBob rainbow meme, says "Great idea!"

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.

Why is a Frankenstein pattern bad?

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.

Recipe card pattern where the entire card links to the recipe, outlined with a dashed border, while favorite and share buttons sit inside it. A badge reads "Frankenstein alert!"

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.

How to spot a Frankenstein pattern

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:

  1. What does it do? Without explanation, can people tell which parts are interactive and what each will do? Can they tell quickly, without stopping to work it out?
  2. What's hidden or buried? Is anything interactive nested inside something else interactive? Does anything only work on hover, right-click, long-press, swipe, or an obscure shortcut?
  3. What are things called? Does every control have a label and/or accessible name that says what it does? Does the accessible name include the visible label?
  4. How do people use it? Can we do everything with a mouse? With only a keyboard, and with visible focus? At 400% zoom and on touch? With assistive technologies?
  5. Is the state clear? Can we tell the state of each control and what changed after an action? Can people avoid mistakes and recover from them easily?
  6. Has anyone else tried it? Have people outside the team, including people who use assistive technology, used it without help?

Ask these early, before prompting or building. If they're hard to answer, we may be building a Frankenstein.

How to fix a Frankenstein pattern

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.

The six steps to fix a Frankenstein pattern: give every control one job, make it discoverable, name things for what they do, define how it's operated, make states apparent, and make sure it works. Arrows loop from each step back to step 1, with a note: "Stuck on a step? Go back to step 1 and simplify the pattern."
  1. Give every control one job: List every action the pattern supports. If one control does two things or is nested, try to split it into separate controls with distinct purposes.
  2. Make it discoverable: Replace hard-to-find interactions (hovers, swipes, obscure keyboard combos) with discoverable, independent controls.
  3. Name things for what they do: Give every control a label and/or accessible name that describes its action. Make sure the accessible name includes the visible label. If we can't label it in a few words, it's probably still doing too much.
  4. Define how it's operated: Spec the interaction before engineering starts, considering multiple interaction methods (e.g., mouse and keyboard). If our spec requires multiple different interactions within one control, it’s probably doing too much.
  5. Make states apparent: Show the state clearly before, during, and after the interaction. Add undo or confirmation for anything destructive or hard to reverse, and make it easy to recover from mistakes.
  6. Make sure it works: Have people outside the team try it without help, including disabled and neurodivergent people and people who use assistive technology, in a range of contexts. Fix what’s not working, then test again.
Recipe card pattern, link and button spec. The title "Lemon garlic chicken" is the only link, an a href element that opens in the same window. The favorite and share icons are button elements named "Save lemon garlic chicken recipe" and "Share lemon garlic chicken recipe."

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.

Let's not abandon our creations

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.

Anna E. Cook
Anna E. Cook
Anna E. Cook is a designer and code writer working across design systems and platform infrastructure. She is currently a Senior Designer at Microsoft and created the LinkedIn Learning course "Auditing Design Systems for Accessibility." Her writing and work live at annaecook.com.
Try zeroheight
The design systems platform that keeps teams and agents in sync
Start for free
Share this post