Ui Patterns logo

Ui Patterns

Community
alpham8
ui-patterns

Apply proven UI component patterns and scanning behaviour to build effective interfaces. Use when you need to: (1) design navigation, forms, buttons, cards, modals, or tables, (2) understand how users scan pages and place content accordingly, (3) choose between competing UI patterns (dropdown vs radio, modal vs inline, carousel vs static), (4) build loading states, notifications, and search interfaces. Complements gestalt-ui (visual grouping) and laws-of-ux (behavioural principles) with concrete component-level guidance.

Overview

Publisheralpham8
Repositoryagentic-webdev
Skill nameui-patterns
Stars
4
Forks
0
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by alpham8 on GitHub. Read the source before you install it.

Installation

Install the Ui Patterns AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/alpham8/agentic-webdev/tree/master/skills/wondelai/ui-patterns
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/alpham8/agentic-webdev.git /tmp/agentic-webdev
mkdir -p .claude/skills
cp -r /tmp/agentic-webdev/skills/wondelai/ui-patterns .claude/skills/ui-patterns
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Ui Patterns in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Ui Patterns on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Ui Patterns is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

UI Patterns

Concrete, evidence-based patterns for building common UI components. This skill answers the question: "How should I build this specific component?"

For visual grouping theory, see gestalt-ui. For behavioural psychology laws, see laws-of-ux. For visual hierarchy and spacing systems, see refactoring-ui. For usability audits, see ux-heuristics.

Core Principle

Follow proven patterns. Innovate on value, not on interaction mechanics. Users spend most of their time on other sites (Jakob's Law). Every component you build should feel familiar unless you have strong evidence that a novel pattern is significantly better.

Scoring

Goal: 10/10. When reviewing or building components, rate 0-10 based on adherence to proven patterns.

  • 9-10: Every component follows established patterns. Scanning flow is optimised. Decision reference followed for all pattern choices.
  • 7-8: Most components are well-patterned. Minor issues: one unconventional choice, missing loading state.
  • 5-6: Mixed adherence. Some components feel right, others require learning or cause confusion.
  • 3-4: Significant pattern violations. Users struggle to predict behaviour.
  • 1-2: Components invented from scratch. Nothing feels familiar or predictable.

The UI Patterns Framework

1. Scanning Patterns -- How Users Actually Look at Pages

Core concept: Users don't read pages linearly -- they scan in predictable patterns. Place content where the eye naturally goes.

Why it works: Eye-tracking research reveals consistent scanning behaviours driven by reading habits and cognitive efficiency.

Key insights:

F-Pattern (Text-Heavy Pages)

The eye moves:

  1. Horizontal scan across the top (headline area)
  2. Shorter horizontal scan slightly below (subheading / first paragraph)
  3. Vertical scan down the left edge, looking for visual cues

Design rules for F-pattern pages:

  • First two paragraphs carry the most important information
  • Start headings and bullet points with information-carrying words ("Users" not "In the case of users")
  • Left-aligned content gets 2-3x more fixation than right-aligned
  • Break walls of text with bold keywords, headings, and bullet points
  • The F-pattern is the default when no visual cues exist -- good design breaks it
Z-Pattern (Minimal-Text Pages)

The eye moves: top-left → top-right → diagonal to bottom-left → bottom-right.

Design rules for Z-pattern pages:

  • Logo/brand: top-left
  • CTA or key action: top-right
  • Key message or value proposition: along the diagonal
  • Primary CTA or conversion action: bottom-right

Best for: landing pages, hero sections, splash screens, marketing pages.

Visual Weight Factors

Elements attract attention based on (strongest to weakest):

  1. Size -- larger elements dominate
  2. Colour and contrast -- vivid/saturated over muted
  3. Whitespace -- isolated elements gain prominence
  4. Shape -- distinctive shapes among uniform ones
  5. Position -- top-left dominance in LTR languages
  6. Imagery -- photos of people naturally attract the eye

Product applications:

ContextApplicationExample
Landing pagesZ-pattern with CTA bottom-rightHero image → headline → feature blocks → "Start free trial"
Blog / docsF-pattern with scannable headingsBold heading → summary → bulleted details → next heading
DashboardsTop-left for most critical KPIRevenue chart in top-left, secondary metrics below
Search resultsLeft-aligned titles, information-denseTitle (bold) → URL → description → metadata

See: references/scanning-patterns.md

2. Navigation Patterns

Core concept: Every page must answer three questions: (1) Where am I? (2) Where can I go? (3) Where have I been?

Why it works: Users need orientation, options, and history. Most responsive navigation handles only "where can I go?" and forgets the other two.

Key insights:

PatternUse whenAvoid when
Persistent top nav<= 7 items, flat hierarchyComplex multi-level structures
Simple toggle (hamburger)Single-level, many items on mobileMulti-level hierarchies
Multi-level toggle2-level hierarchy (sweet spot for most sites)> 2 levels of depth
Off-canvas / drawerComplex menus, mobile-firstDesktop with sufficient space
Tab bar (mobile)3-5 primary destinations> 5 items
SidebarMany sections, persistent access (apps, dashboards)Content-focused sites (blogs, marketing)

Product applications:

ContextApplicationExample
SaaS dashboardSidebar nav + top barSlack, Notion, Linear
E-commerceTop nav with categories + breadcrumbsProduct categories as top-level, breadcrumbs on product pages
Marketing siteSimple top nav (5-7 links)Home, Features, Pricing, Docs, Blog, Login
Mobile appBottom tab bar (4-5 tabs)Home, Search, Create, Notifications, Profile

Navigation rules:

  • Always label hamburger icons with "Menu" text -- icons alone are ambiguous
  • Show breadcrumbs at all viewport sizes, not just desktop
  • Build navigation progressively -- it must work without JavaScript
  • Current page indicator must remain visible in responsive navigation
  • No mega-menus on mobile; no more than 3 levels of nesting

See: references/navigation-forms.md

3. Form Patterns

Core concept: Forms are the highest-friction UI pattern. Every unnecessary field, confusing label, or validation delay reduces completion rates.

Why it works: Research shows most forms can remove 20-60% of their fields without impacting data quality. Perceived complexity reduces completion rates more than actual complexity.

Key insights:

Layout
  • Labels above fields -- always. Closest visual proximity.
  • One column for forms -- multi-column increases completion time by 15-25%
  • Group related fields with visible boundaries and tighter spacing within groups
  • Auto-focus the first field to reduce interaction cost
  • Size fields proportionally to expected input (postcode = short, address = long)
Input Optimisation
  • Match keyboard to input type: type="email", type="tel", type="number", type="date"
  • Use input masking for formatted data (phone, dates, credit cards)
  • Enable browser autocomplete / autofill (30% faster completion per Google research)
  • Show/hide password toggle instead of "confirm password" field
  • Avoid dropdowns on mobile -- prefer radio buttons, segmented controls, or steppers
Validation
  • Validate inline after the user leaves the field (on blur), not while typing
  • Show errors next to the field, not only in a top summary
  • Plain language: "Email must include @" not "Error: invalid format"
  • Never rely on colour alone for error indication -- add icons and text
  • Preserve user input when errors occur -- never clear fields on error
  • Show all errors at once, not one at a time
Friction Reduction
  • Remove every non-essential field
  • Explain why sensitive data is needed ("We need your phone for delivery updates")
  • Mark only optional fields (if most are required); use "Optional" text, not asterisks
  • Persist form data across accidental page reloads

Product applications:

ContextApplicationExample
SignupMinimal fields (email + password)Defer profile completion to after signup
CheckoutAuto-fill + address API + card scanningGoogle Places autocomplete, camera card capture
ContactName + email + message (3 fields)No phone, no company, no dropdown for "topic"
SettingsSection-by-section with inline saveEach section has its own "Save" button

See: references/navigation-forms.md

4. Button Patterns

Core concept: Buttons must look clickable, communicate their action, and follow a clear visual hierarchy.

Key insights:

Visual Hierarchy
LevelStyleExamples
PrimaryFilled, high contrast, strongest visual weight"Create Account", "Submit Order", "Get Started"
SecondaryOutlined or ghost, lower visual weight"Cancel", "Back", "Learn More"
TertiaryText-only, minimal visual weight"Skip", "Maybe Later", "Dismiss"
DestructiveDistinct colour (typically red), requires confirmation"Delete Account", "Remove Item"

Rule: Never give "Cancel" the same visual weight as "Submit". The primary action must dominate.

Sizing and Touch Targets
  • Minimum: 44x44 CSS pixels (10mm physical)
  • Primary action: largest button in context
  • Breathing room between adjacent buttons (minimum 8px, recommended 16px)
  • Full-width on mobile for primary actions
Labeling
  • Action verbs describing the outcome: "Create Account", "Send Message", "Download PDF"
  • Must answer: "What happens when I click this?"
  • Avoid: "OK", "Submit", "Yes/No", "Click Here"
Required States
  • Default -- resting appearance
  • Hover -- cursor feedback (desktop)
  • Active/Pressed -- click confirmation
  • Focused -- keyboard navigation indicator (never remove without replacement)
  • Disabled -- muted with explanation (prefer enabled + validate on submit)
  • Loading -- spinner or progress during async operations

5. Card Patterns

Core concept: Cards group heterogeneous content into discrete, scannable, often interactive units.

Key insights:

  • One primary action per card; secondary actions in overflow menu
  • Entire card clickable for the primary action (not just a "Read more" link)
  • Consistent dimensions within a grid (same height per row minimum)
  • Internal hierarchy: Image > Title > Description > Meta
  • Maximum 3-4 pieces of information per card

6. Modal & Dialog Patterns

Core concept: Modals interrupt flow and demand immediate attention. Use only when interruption is justified.

When to use: Destructive action confirmation, short decision-required forms, critical alerts.

When NOT to use: Informational content, long forms, marketing/upsells, errors (use inline).

Rules:

  • Always provide visible close button (X) AND Escape key
  • Dim/blur the background (figure-ground separation)
  • Focus trap: tab cycling stays within the modal
  • Return focus to trigger element on close
  • Never stack modals
  • Mobile: consider full-screen or bottom sheet instead of centred modal

7. Loading State Patterns

Core concept: Every async operation needs appropriate feedback based on its duration.

DurationPatternExample
< 100msNo indicatorDirect manipulation (toggle, click)
100-400msSubtle indicatorButton state change, micro-animation
400ms-2sSpinner or skeletonContent loading, navigation
2-10sProgress bar + percentageFile upload, data processing
> 10sProgress + status messages"Generating report... Analysing data..."

Skeleton screens:

  • Mirror the layout of the content being loaded
  • Subtle shimmer/pulse animation
  • Replace with real content progressively (no flash)
  • Better than spinners for content-heavy pages

8. Notification Patterns

TypePersistencePositionUse case
ToastAuto-dismiss (3-5s)Top-right or bottomSuccess confirmations, non-critical info
BannerPersistent until dismissedTop of page/sectionSystem messages, warnings
InlinePersistentNext to source elementValidation errors, field-level feedback
ModalRequires user actionCentre overlayDestructive action confirmation

Rules:

  • Success notifications auto-dismiss; errors persist until acknowledged
  • Errors always colour-independent (icon + text, not just red colour)
  • Stack multiple notifications vertically, don't overlap
  • Include an action when recovery is possible ("Undo", "Retry")

Pattern Decision Reference

When choosing between competing patterns, use this table:

DecisionChoose AChoose BWhy
Hamburger vs visible navVisible when space allowsHamburger on mobile onlyHidden nav reduces discoverability by 50%+
Dropdown vs radio buttons (mobile)Radio / segmented controlDropdown only for 10+ optionsDropdowns need 2 taps and hide options
Placeholder vs labelAlways visible labelsNever placeholder-onlyPlaceholders disappear (recognition > recall)
Modal vs inlineInline when possibleModal only for interruptionModals interrupt flow; require focus management
Carousel vs staticStatic contentCarousel only for media galleries< 1% interaction past first slide
Infinite scroll vs paginationPagination for goal-oriented tasksInfinite scroll for browsing/feedsPagination preserves position and back button
Icon-only vs icon + labelIcon + labelIcon-only for universal icons (X, search, home)Most icons are ambiguous without text
Confirm password vs toggleShow/hide toggleNever confirm passwordSingle field + toggle reduces errors
Disabled button vs enabledEnabled + validate on submitDisabled only with visible explanationDisabled buttons don't explain what's wrong
Skeleton vs spinnerSkeleton for content loadingSpinner for actions (submit, search)Skeletons reduce perceived wait time
Bottom sheet vs modal (mobile)Bottom sheet for selections/actionsModal for critical confirmationsBottom sheets are thumb-friendly and dismissible
Tabs vs accordionTabs when sections are equal priorityAccordion for progressive disclosureTabs show all labels; accordions save space

Common Mistakes

MistakeWhy It FailsFix
Form labels as placeholdersLabels disappear on focusAlways use visible labels above inputs
Multi-column forms15-25% slower completionUse single-column layout
Validate while user is still typingPremature errors frustrate and distractValidate on blur (when user leaves field)
Icon-only navigation without labelsUsers can't predict meaningAdd text labels to all navigation icons
Equal-weight Cancel and Submit buttonsUsers click the wrong onePrimary action gets strong visual weight; secondary gets weak
Carousel for important content< 1% see past first slideUse static layout or prioritise content
Modal for non-critical informationUnnecessary interruptionUse inline content, banners, or tooltips
No loading feedback for actions > 400msUsers think the system is brokenAdd spinners, skeletons, or optimistic UI

Quick Diagnostic

QuestionIf NoAction
Does every page answer "Where am I?"Missing current location indicatorAdd active nav state, breadcrumbs, or page title
Do forms use labels above fields (not placeholders)?Recognition violationAdd persistent labels
Is there exactly one primary CTA per view?Competing actionsDemote secondary actions to outlined/text style
Do all async actions show feedback within 400ms?Doherty violationAdd loading states appropriate to duration
Are dropdown menus avoided on mobile?Hick's Law + frictionReplace with radio buttons or segmented controls
Can users dismiss modals with X, Escape, and backdrop click?Control violationAdd all three dismissal methods

Reference Files

Further Reading

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Ui Patterns AI skill do?

Apply proven UI component patterns and scanning behaviour to build effective interfaces. Use when you need to: (1) design navigation, forms, buttons, cards, modals, or tables, (2) understand how users scan pages and place content accordingly, (3) choose between competing UI patterns (dropdown vs radio, modal vs inline, carousel vs static), (4) build loading states, notifications, and search interfaces. Complements gestalt-ui (visual grouping) and laws-of-ux (behavioural principles) with concrete component-level guidance.

Why use Ui Patterns on TypingMind?

Because you install it once and use it with any model. Ui Patterns is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Ui Patterns in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/alpham8/agentic-webdev/tree/master/skills/wondelai/ui-patterns. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Ui Patterns?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Ui Patterns?

As many as you like. As long as a model supports skills, you can use Ui Patterns with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Ui Patterns AI skill free?

Yes. It is published on GitHub by alpham8 under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇