ux-principles

manutej/luxor-claude-marketplace · updated Apr 8, 2026

MDX-style export adds YAML metadata + attribution linking explainx.ai and this canonical listing URL.

$npx skills add https://github.com/manutej/luxor-claude-marketplace --skill ux-principles
0 commentsdiscussion
summary

Apply this skill when you need to:

skill.md

UX Principles Skill

When to Use This Skill

Apply this skill when you need to:

  • Design User-Centered Interfaces: Create products that prioritize user needs and behaviors
  • Conduct User Research: Plan and execute qualitative and quantitative research studies
  • Evaluate Usability: Assess interfaces using established heuristics and testing methods
  • Ensure Accessibility: Design inclusive experiences that work for users with diverse abilities
  • Optimize User Flows: Improve task completion rates and reduce friction in user journeys
  • Measure UX Performance: Define and track meaningful metrics for user experience quality
  • Apply Design Thinking: Solve complex problems through human-centered design processes
  • Create Information Architecture: Organize content in ways that match user mental models
  • Run Usability Testing: Plan, conduct, and analyze user testing sessions
  • Build Personas and Journey Maps: Document user behaviors, needs, and pain points

Core Concepts

User-Centered Design (UCD)

User-centered design is a framework that places users at the center of the design process through iterative cycles of research, design, testing, and refinement.

Four Fundamental Principles:

  1. Early Focus on Users and Tasks

    • Understand user characteristics, needs, and goals before designing
    • Observe users in their natural environment
    • Identify tasks users need to accomplish
    • Map current workflows and pain points
  2. Empirical Measurement

    • Test designs with real users performing real tasks
    • Collect quantitative and qualitative data
    • Use objective metrics (task completion, time, errors)
    • Gather subjective feedback (satisfaction, preferences)
  3. Iterative Design

    • Design, test, measure, and redesign in cycles
    • Start with low-fidelity prototypes
    • Refine based on user feedback
    • Continuously improve until goals are met
  4. Integrated Design

    • Consider the entire user experience holistically
    • Balance user needs, business goals, and technical constraints
    • Involve multidisciplinary teams
    • Design for consistency across touchpoints

Design Thinking

Design thinking is a human-centered approach to innovation that integrates user needs, technological possibilities, and business viability.

Five-Stage Process:

  1. Empathize: Understand users through research and observation
  2. Define: Synthesize findings into clear problem statements
  3. Ideate: Generate diverse solutions through brainstorming
  4. Prototype: Build tangible representations of ideas
  5. Test: Gather feedback and refine solutions

Key Principles:

  • Focus on human values and needs
  • Show don't tell (use prototypes)
  • Create clarity from complexity
  • Get experimental and take risks
  • Be mindful of process and bias toward action
  • Radical collaboration across disciplines

Usability Heuristics

Nielsen's 10 Usability Heuristics

Jakob Nielsen's heuristics are foundational principles for evaluating interface usability.

1. Visibility of System Status

Principle: The system should always keep users informed about what is going on through appropriate feedback within reasonable time.

Guidelines:

  • Provide immediate feedback for user actions
  • Use progress indicators for operations taking >1 second
  • Show system state clearly (loading, processing, saved)
  • Display current location in navigation
  • Indicate selected items, active states, and modes

Examples:

  • Loading spinners during data fetches
  • "Saving..." then "Saved" confirmations
  • Progress bars for uploads/downloads
  • Breadcrumb navigation showing current page
  • Highlighted active tab or menu item

2. Match Between System and Real World

Principle: The system should speak the users' language, using words, phrases, and concepts familiar to them rather than system-oriented terms.

Guidelines:

  • Use terminology from the user's domain
  • Follow real-world conventions
  • Present information in natural, logical order
  • Use metaphors that match user mental models
  • Avoid jargon, acronyms, and technical language

Examples:

  • Shopping cart icon for e-commerce
  • Trash/recycle bin for deleted items
  • Folders for file organization
  • "Inbox" instead of "Message Queue"
  • Date formats matching user's locale

3. User Control and Freedom

Principle: Users often choose system functions by mistake and need a clearly marked "emergency exit" to leave unwanted states without going through an extended dialogue.

Guidelines:

  • Provide undo and redo functionality
  • Allow users to cancel operations
  • Enable easy navigation backward and forward
  • Support escape from modal states
  • Make exit options obvious

Examples:

  • Undo/redo buttons in editors
  • Cancel button on forms
  • Back button in navigation
  • "X" to close modals and overlays
  • Ctrl+Z keyboard shortcut

4. Consistency and Standards

Principle: Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform and industry conventions.

Guidelines:

  • Use consistent terminology throughout
  • Maintain visual consistency (colors, fonts, spacing)
  • Follow platform conventions (iOS, Android, Web)
  • Use standard UI patterns and components
  • Create and follow a design system

Examples:

  • Blue underlined text for links
  • Submit buttons on the right, Cancel on the left
  • Search icon as magnifying glass
  • Settings gear/cog icon
  • Consistent button styles and behaviors

5. Error Prevention

Principle: Even better than good error messages is careful design that prevents problems from occurring in the first place.

Guidelines:

  • Eliminate error-prone conditions
  • Use constraints and validation
  • Provide helpful defaults
  • Ask for confirmation before destructive actions
  • Design for forgiving interactions

Examples:

  • Date pickers instead of text input
  • Disabling invalid options
  • Inline form validation
  • "Are you sure?" confirmations for delete
  • Auto-save functionality

6. Recognition Rather Than Recall

Principle: Minimize the user's memory load by making objects, actions, and options visible. Users should not have to remember information from one part of the dialogue to another.

Guidelines:

  • Make options and actions visible
  • Show recently used items
  • Display context and helpful information
  • Use visual aids and previews
  • Provide tooltips and inline help

Examples:

  • Autocomplete in search boxes
  • Recently opened files list
  • Visible menu items vs. hidden commands
  • Color palette showing available colors
  • Form field placeholders with examples

7. Flexibility and Efficiency of Use

Principle: Accelerators—unseen by novice users—may speed up interaction for expert users, allowing the system to cater to both inexperienced and experienced users.

Guidelines:

  • Provide keyboard shortcuts for power users
  • Allow customization and personalization
  • Support multiple ways to accomplish tasks
  • Offer both simple and advanced features
  • Enable bulk operations and automation

Examples:

  • Keyboard shortcuts (Ctrl+C, Ctrl+V)
  • Quick actions and gestures
  • Advanced search filters
  • Customizable toolbars
  • Templates and saved preferences

8. Aesthetic and Minimalist Design

Principle: Dialogues should not contain information that is irrelevant or rarely needed. Every extra unit of information competes with relevant units and diminishes their visibility.

Guidelines:

  • Keep content focused and relevant
  • Remove unnecessary elements
  • Use white space effectively
  • Prioritize information hierarchy
  • Progressive disclosure for advanced features

Examples:

  • Clean, uncluttered interfaces
  • Collapsible sections for details
  • Focus on primary actions
  • Minimal decoration and ornamentation
  • Clear visual hierarchy

9. Help Users Recognize, Diagnose, and Recover from Errors

Principle: Error messages should be expressed in plain language, precisely indicate the problem, and constructively suggest a solution.

Guidelines:

  • Write clear, human-readable error messages
  • Explain what went wrong and why
  • Suggest specific solutions
  • Use appropriate visual indicators (color, icons)
  • Avoid technical codes and jargon

Examples:

  • "Email address is required" vs. "Error 422"
  • Highlighting the field with the error
  • Suggestions: "Did you mean gmail.com?"
  • Specific guidance: "Password must be at least 8 characters"
  • Recovery actions: "Try again" or "Reset password"

10. Help and Documentation

Principle: Even though it's better if the system can be used without documentation, it may be necessary to provide help. Such information should be easy to search, focused on the user's task, and list concrete steps.

Guidelines:

  • Make help easily accessible
  • Provide context-sensitive help
  • Use clear, concise language
  • Include visual examples
  • Enable searching and browsing

Examples:

  • Question mark icons for contextual help
  • Interactive tutorials and walkthroughs
  • Searchable knowledge base
  • Video demonstrations
  • FAQ sections organized by task

Gestalt Principles in UI Design

Gestalt principles describe how humans perceive visual elements as organized patterns rather than separate components.

Key Principles:

  1. Proximity: Elements close together are perceived as related

    • Group related form fields
    • Space navigation items by category
    • Cluster related content blocks
  2. Similarity: Similar elements are perceived as part of a group

    • Use consistent styling for related actions
    • Match colors for similar functionality
    • Apply uniform shapes to category items
  3. Continuity: Elements arranged on a line or curve are perceived as related

    • Align form labels and inputs
    • Create visual flow with layouts
    • Use lines to connect related items
  4. Closure: Humans complete incomplete shapes in their minds

    • Use subtle borders or backgrounds
    • Implied boundaries for cards
    • Negative space to define areas
  5. Figure/Ground: Elements are perceived as either foreground or background

    • Use contrast to emphasize primary content
    • Blur backgrounds for modal focus
    • Layer elements with depth

User Psychology

Cognitive Load

Cognitive load refers to the amount of mental effort required to use an interface. Reducing cognitive load improves usability and user satisfaction.

Types of Cognitive Load:

  1. Intrinsic Load: Inherent complexity of the task

    • Cannot be eliminated, only managed
    • Break complex tasks into smaller steps
    • Provide scaffolding and support
  2. Extraneous Load: Unnecessary mental effort from poor design

    • Can and should be eliminated
    • Caused by confusing layouts, unclear labels, inconsistency
    • Reduce through good UX practices
  3. Germane Load: Effort required to learn and internalize patterns

    • Beneficial cognitive load
    • Supports skill development and mastery
    • Invest in onboarding and progressive learning

Strategies to Reduce Cognitive Load:

  • Chunking: Group related information (phone numbers: 123-456-7890)
  • Recognition over Recall: Show options instead of requiring memory
  • Progressive Disclosure: Reveal complexity gradually
  • Defaults: Provide sensible pre-selections
  • Visual Hierarchy: Guide attention to important elements
  • Familiar Patterns: Use known conventions and metaphors
  • Clear Labels: Use descriptive, unambiguous text
  • Minimize Choices: Apply Hick's Law (more options = longer decision time)

Mental Models

A mental model is a user's internal representation of how something works. Effective UX design aligns with user mental models.

Understanding Mental Models:

  • Formed through prior experience and learning
  • May not match actual system implementation
  • Vary across different user groups
  • Influence expectations and predictions
  • Drive user behavior and decisions

Designing for Mental Models:

  1. Research User Expectations

    • Conduct user interviews
    • Observe task completion attempts
    • Ask users to predict outcomes
    • Map user workflows
  2. Match or Teach

    • Align design with existing mental models when possible
    • When innovation required, teach new models explicitly
    • Use familiar metaphors as bridges
    • Provide clear conceptual models
  3. Test Assumptions

    • Validate mental model alignment through testing
    • Identify mismatches and confusion points
    • Iterate to improve alignment
    • Document common misconceptions

Common Mental Model Mismatches:

  • File systems vs. search-based organization
  • Hierarchical navigation vs. networked information
  • Linear processes vs. flexible workflows
  • Technical accuracy vs. user understanding

Affordances and Signifiers

Affordances: Properties of an object that show what actions can be performed with it.

  • Perceived affordances matter more than actual affordances in UI
  • Buttons afford clicking through their appearance
  • Text fields afford typing through cursor changes
  • Sliders afford dragging through visible handles

Signifiers: Cues that communicate where action should take place.

  • Visual indicators of affordances
  • Underlines on links (signify clickability)
  • Pointer cursor change (signify interaction)
  • Button shading and borders (signify pressability)
  • Drag handles (signify movability)

Design Implications:

  • Make interactive elements look interactive
  • Provide visual feedback on hover and focus
  • Use consistent signifiers throughout interface
  • Don't make non-interactive elements look clickable
  • Test with users to validate perceived affordances

Fitts's Law

Principle: The time to acquire a target is a function of the distance to and size of the target.

Formula: T = a + b × log₂(D/W + 1)

  • T = time to move to target
  • D = distance to target
  • W = width of target
  • a, b = empirically determined constants

UI Design Applications:

  1. Large Targets: Make clickable elements bigger

    • Minimum touch target: 44×44 pixels (Apple), 48×48 pixels (Android)
    • Larger buttons for primary actions
    • Expand hover areas beyond visible boundaries
  2. Proximity: Place related items close together

    • Position tooltips near triggers
    • Keep form labels adjacent to inputs
    • Group related actions in toolbars
  3. Edge Cases: Screen edges are easy targets (infinite width)

    • macOS menu bar at top edge
    • Windows start button at bottom corner
    • Mobile navigation at screen bottom
  4. Context Menus: Appear at cursor location

    • Zero distance to travel
    • Faster than menu bar navigation
    • Right-click or long-press patterns

Hick's Law

Principle: The time it takes to make a decision increases logarithmically with the number of choices.

Formula: T = b × log₂(n + 1)

  • T = time to make decision
  • n = number of choices
  • b = empirically determined constant

Design Implications:

  1. Reduce Options: Show only necessary choices

    • Progressive disclosure for advanced options
    • Smart defaults to eliminate decisions
    • Remove rarely used features
  2. Categorize: Group options into logical categories

    • Mega menus with organized sections
    • Filters and facets for narrowing
    • Stepped navigation (breadth vs. depth)
  3. Prioritize: Highlight recommended or popular options

    • "Most popular" indicators
    • "Recommended for you" suggestions
    • Default selections for common choices
  4. Context: Show relevant options for current task

    • Contextual menus based on selection
    • Adaptive interfaces based on usage
    • Role-based views and permissions

Miller's Law

Principle: The average person can hold 7 (±2) items in working memory.

Design Applications:

  1. Chunk Information: Group content into 5-9 items

    • Navigation menu items
    • Dashboard widgets
    • List items before requiring scrolling
  2. Break Down Complex Tasks: Divide into steps

    • Multi-step forms with progress indicators
    • Wizards for complex configurations
    • Onboarding flows with clear stages
  3. Use Visual Aids: Reduce memory requirements

    • Icons alongside text labels
    • Color coding for categories
    • Visual grouping of related items
  4. Provide References: Make information available

    • Tooltips for additional context
    • Inline help and examples
    • Summary views of previous inputs

User Research

Research Methods Overview

Qualitative Methods: Explore motivations, behaviors, and mental models

  • User interviews
  • Contextual inquiry
  • Focus groups
  • Diary studies
  • Think-aloud protocols

Quantitative Methods: Measure behaviors and validate hypotheses

  • Surveys and questionnaires
  • Analytics and metrics
  • A/B testing
  • Card sorting (with statistical analysis)
  • Tree testing

User Interviews

Purpose: Deep understanding of user needs, goals, behaviors, and pain points.

Best Practices:

  1. Preparation

    • Define research questions and objectives
    • Create discussion guide (not rigid script)
    • Recruit representative participants (5-8 per user segment)
    • Choose appropriate setting (user's environment often best)
  2. During Interviews

    • Build rapport and trust
    • Ask open-ended questions
    • Use "5 Whys" technique to dig deeper
    • Observe behavior and environment
    • Avoid leading questions
    • Listen more than talk (80/20 rule)
  3. Question Types

    • Background: "Tell me about your role..."
    • Behavior: "Walk me through how you currently..."
    • Pain points: "What's frustrating about..."
    • Goals: "What are you trying to accomplish..."
    • Workarounds: "How do you handle it when..."
  4. Analysis

    • Transcribe or take detailed notes
    • Identify patterns across participants
    • Extract quotes for personas and presentations
    • Synthesize findings into themes
    • Validate with stakeholders

Surveys and Questionnaires

Purpose: Gather quantitative data from larger samples to measure attitudes, behaviors, and preferences.

Design Principles:

  1. Question Design

    • Use clear, unambiguous language
    • Avoid double-barreled questions
    • Use balanced scales (Likert: 1-5 or 1-7)
    • Include "prefer not to answer" options
    • Randomize answer order to reduce bias
  2. Survey Structure

    • Start with easy, engaging questions
    • Group related questions together
    • Place demographics at the end
    • Keep surveys as short as possible
    • Show progress indicator for longer surveys
  3. Question Types

    • Multiple choice (single select)
    • Checkboxes (multiple select)
    • Rating scales (satisfaction, agreement)
    • Open-ended (for qualitative insights)
    • Ranking (priority ordering)
  4. Sample Size

    • Calculate required sample for statistical significance
    • Account for response rate (often 10-30%)
    • Ensure representative distrib
how to use ux-principles

How to use ux-principles on Cursor

AI-first code editor with Composer

1

Prerequisites

Before installing skills in Cursor, ensure your development environment meets these requirements:

  • Cursor installed and configured on your development machine
  • Node.js version 16.0+ with npm package manager (verify with node --version)
  • Active project directory or workspace where you want to add ux-principles
2

Execute installation command

Execute the skills CLI command in your project's root directory to begin installation:

$npx skills add https://github.com/manutej/luxor-claude-marketplace --skill ux-principles

The skills CLI fetches ux-principles from GitHub repository manutej/luxor-claude-marketplace and configures it for Cursor.

3

Select Cursor when prompted

The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:

◆ Which agents do you want to install to?
│ ── Universal (.agents/skills) ── always included ────
│ • Amp
│ • Antigravity
│ • Cline
│ • Codex
│ ●Cursor(selected)
│ • Cursor
│ • Windsurf
4

Verify installation

Confirm successful installation by checking the skill directory location:

.cursor/skills/ux-principles

Reload or restart Cursor to activate ux-principles. Access the skill through slash commands (e.g., /ux-principles) or your agent's skill management interface.

Security & Verification Notice

We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.

Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.

List & Monetize Your Skill

Submit your Claude Code skill and start earning

GET_STARTED →

Use Cases

User Story & Requirements Generation

Create detailed user stories, acceptance criteria, and feature specs

Example

Generate user stories for 'password reset feature' with acceptance criteria, edge cases, and test scenarios

Reduce spec writing time by 50%, ensure comprehensive coverage

Competitive Analysis

Research competitors, compare features, identify gaps

Example

Analyze 5 competitor products, create feature comparison matrix, suggest differentiation opportunities

Complete competitive research in 2 hours instead of 2 days

Roadmap Prioritization

Evaluate features using frameworks (RICE, ICE, Kano) and create prioritized backlogs

Example

Score 20 feature ideas using RICE framework, generate prioritized roadmap with rationale

Make data-driven prioritization decisions faster

Stakeholder Communication

Draft PRDs, status updates, and stakeholder presentations

Example

Create executive summary of Q3 roadmap, monthly progress report, feature launch announcement

Save 3-5 hours/week on communication overhead

Implementation Guide

Prerequisites

  • Claude Desktop or compatible AI client
  • Access to product documentation and roadmap tools (Jira, Notion, etc.)
  • Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
  • Stakeholder contact information and communication channels

Time Estimate

30-60 minutes to see productivity improvements

Installation Steps

  1. 1.Install product management skill
  2. 2.Start with user story generation for known feature
  3. 3.Progress to competitive analysis: research 2-3 competitors
  4. 4.Use for roadmap prioritization: apply RICE/ICE scoring
  5. 5.Draft stakeholder communications and refine based on feedback
  6. 6.Build template library for recurring PM tasks
  7. 7.Share effective prompts with product team

Common Pitfalls

  • Not validating competitive research—verify facts before sharing
  • Accepting user stories without involving engineering team
  • Over-relying on frameworks without qualitative judgment
  • Not customizing outputs to company culture and communication style
  • Skipping stakeholder validation of generated requirements

Best Practices

✓ Do

  • +Validate research and competitive analysis with real data
  • +Collaborate with engineering when generating technical requirements
  • +Customize frameworks and templates to your company context
  • +Use skill for first drafts, refine with stakeholder input
  • +Document successful prompt patterns for PM tasks
  • +Combine AI efficiency with human judgment and intuition

✗ Don't

  • Don't publish competitive analysis without fact-checking
  • Don't finalize user stories without engineering review
  • Don't make prioritization decisions solely on AI scoring
  • Don't skip customer validation of generated requirements
  • Don't ignore company-specific context and culture

💡 Pro Tips

  • Provide context: company goals, constraints, customer feedback
  • Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
  • Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
  • Use skill for 70% generation + 30% customization to company needs

When to Use This

✓ Use When

Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.

✗ Avoid When

Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.

Learning Path

  1. 1Basic: user stories, feature specs, status updates
  2. 2Intermediate: competitive analysis, prioritization frameworks, PRDs
  3. 3Advanced: product strategy, go-to-market planning, OKR setting
  4. 4Expert: product vision, market positioning, business model innovation

Discussion

Product Hunt–style comments (not star reviews)
  • No comments yet — start the thread.
general reviews

Ratings

4.554 reviews
  • Shikha Mishra· Dec 24, 2024

    ux-principles has been reliable in day-to-day use. Documentation quality is above average for community skills.

  • Min Yang· Dec 12, 2024

    We added ux-principles from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.

  • Chinedu Menon· Dec 8, 2024

    ux-principles reduced setup friction for our internal harness; good balance of opinion and flexibility.

  • Maya Malhotra· Dec 4, 2024

    Solid pick for teams standardizing on skills: ux-principles is focused, and the summary matches what you get after install.

  • Diya Sanchez· Nov 27, 2024

    ux-principles has been reliable in day-to-day use. Documentation quality is above average for community skills.

  • Jin Iyer· Nov 23, 2024

    I recommend ux-principles for anyone iterating fast on agent tooling; clear intent and a small, reviewable surface area.

  • Rahul Santra· Nov 15, 2024

    ux-principles reduced setup friction for our internal harness; good balance of opinion and flexibility.

  • Jin Mensah· Nov 3, 2024

    ux-principles fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.

  • Tariq Menon· Oct 22, 2024

    ux-principles has been reliable in day-to-day use. Documentation quality is above average for community skills.

  • Diya Patel· Oct 18, 2024

    ux-principles fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.

showing 1-10 of 54

1 / 6