user-experience

name	user-experience
description	Comprehensive user experience design and strategy
category	interdisciplinary
difficulty	intermediate
tags	["ux","design","strategy","research"]
author	OpenCode Community
version	1
last_updated	2024-01-15T00:00:00.000Z

User Experience

What I Do

I am User Experience (UX), the holistic discipline encompassing all aspects of a user's interaction with a product, service, or system. I go beyond interface design to consider the entire user journey including emotions, perceptions, and behaviors. I integrate user research, design, and strategy to create meaningful, effective experiences. I measure success through metrics like task completion, satisfaction, and emotional response. I advocate for users while balancing business goals and technical constraints. I create frameworks for consistent, empathetic design across products and touchpoints. I believe that great experiences don't happen by accident—they require intentional design and continuous iteration.

When to Use Me

• Designing new products or features
• Improving existing products
• Creating design systems
• Developing brand experience strategy
• Planning user research initiatives
• Aligning teams around user needs
• Measuring and tracking UX metrics
• Training UX teams and stakeholders
• Conducting UX audits

Core Concepts

User Journey: Sequence of steps users take to accomplish goals.

Personas: Fictional representations of user types.

Jobs to Be Done: Underlying motivations driving user behavior.

Experience Maps: Visual representation of user experience across touchpoints.

Design Thinking: Human-centered problem-solving methodology.

Service Design: Designing service ecosystems holistically.

Emotional Design: Designing for emotional response and connection.

UX Metrics: Quantitative measures of user experience success.

Code Examples

Example 1: User Journey Mapping

#!/usr/bin/env python3
"""
User Journey Mapping Framework
"""
from dataclasses import dataclass, field
from datetime import datetime
from typing import List, Dict, Optional
from enum import Enum
import json

class Stage(Enum):
    AWARENESS = "awareness"
    CONSIDERATION = "consideration"
    DECISION = "decision"
    RETENTION = "retention"
    ADVOCACY = "advocacy"

class TouchpointType(Enum):
    WEBSITE = "website"
    MOBILE_APP = "mobile_app"
    EMAIL = "email"
    SOCIAL = "social"
    CUSTOMER_SERVICE = "customer_service"
    PHYSICAL = "physical"
    CHAT = "chat"

@dataclass
class Touchpoint:
    name: str
    type: TouchpointType
    channel: str
    description: str
    pain_points: List[str]
    opportunities: List[str]
    metrics: Dict[str, float]

@dataclass
class JourneyStage:
    name: 
    stage: Stage
    touchpoints: [Touchpoint]
    user_goals: []
    emotions: []
    questions: []
    barriers: []
    success_metrics: []


 :
    journey_id: 
    persona: 
    primary_goal: 
    stages: [JourneyStage]
    created_at: datetime
    last_updated: datetime

 :
     ():
        .journeys: [, UserJourney] = {}
        .templates: [, UserJourney] = {}
    
     () -> UserJourney:
        journey = UserJourney(
            journey_id=journey_id,
            persona=persona,
            primary_goal=primary_goal,
            stages=[],
            created_at=datetime.now(),
            last_updated=datetime.now()
        )
        .journeys[journey_id] = journey
         journey
    
     ():
         journey_id  .journeys:
            .journeys[journey_id].stages.append(stage)
            .journeys[journey_id].last_updated = datetime.now()
    
     () -> :
        journey = .journeys.get(journey_id)
          journey:
             {: }
        
         {
            : {
                : journey.journey_id,
                : journey.persona,
                : journey.primary_goal,
                : (journey.stages),
                : (
                    (stage.touchpoints)  stage  journey.stages
                )
            },
            : ._analyze_touchpoints(journey),
            : ._analyze_pain_points(journey),
            : ._analyze_emotions(journey),
            : ._generate_opportunities(journey),
            : ._generate_recommendations(journey)
        }
    
     () -> :
        touchpoint_counts = {}
         stage  journey.stages:
             tp  stage.touchpoints:
                touchpoint_counts[tp.name] = touchpoint_counts.get(tp.name, ) + 
        
         {
            : touchpoint_counts,
            : (touchpoint_counts.items(), key= x: x[]),
            : ._group_by_type(journey)
        }
    
     () -> :
        by_type = {}
         stage  journey.stages:
             tp  stage.touchpoints:
                 tp..value   by_type:
                    by_type[tp..value] = []
                by_type[tp..value].append({
                    : tp.name,
                    : stage.name
                })
         by_type
    
     () -> :
        all_pain_points = []
         stage  journey.stages:
            all_pain_points.extend(stage.pain_points)
        
         {
            : (all_pain_points),
            : ((all_pain_points)),
            : {
                stage.name: stage.pain_points 
                 stage  journey.stages 
                 stage.pain_points
            }
        }
    
     () -> :
        emotion_counts = {}
         stage  journey.stages:
             emotion  stage.emotions:
                emotion_counts[emotion] = emotion_counts.get(emotion, ) + 
        
         {
            : emotion_counts,
            : (
                v  k, v  emotion_counts.items() 
                 k.lower()  [, , , ]
            ),
            : (
                v  k, v  emotion_counts.items() 
                 k.lower()  [, , , ]
            )
        }
    
     () -> []:
        opportunities = []
         stage  journey.stages:
             tp  stage.touchpoints:
                 opp  tp.opportunities:
                    opportunities.append({
                        : opp,
                        : stage.name,
                        : tp.name,
                        :   stage.stage  [Stage.DECISION, Stage.RETENTION]  
                    })
         (opportunities, key= x: x[], reverse=)
    
     () -> []:
        recommendations = []
        
        
         stage  journey.stages:
             stage.barriers:
                recommendations.append({
                    : ,
                    : ,
                    : stage.name,
                    : ,
                    : stage.barriers
                })
        
        
        emotion_analysis = ._analyze_emotions(journey)
         emotion_analysis[] > emotion_analysis[]:
            recommendations.append({
                : ,
                : ,
                : 
            })
        
         recommendations



framework = JourneyMappingFramework()


journey = framework.create_journey(
    ,
    persona=,
    primary_goal=
)


framework.add_stage(, JourneyStage(
    name=,
    stage=Stage.AWARENESS,
    touchpoints=[
        Touchpoint(
            name=,
            =TouchpointType.WEBSITE,
            channel=,
            description=,
            pain_points=[, ],
            opportunities=[, ],
            metrics={: , : }
        )
    ],
    user_goals=[, ],
    emotions=[, ],
    questions=[, ],
    barriers=[, ],
    success_metrics=[, ]
))

(json.dumps(framework.generate_map(), indent=))

Example 2: UX Metrics Dashboard

@dataclass
class UXMetric:
    name: str
    value: float
    unit: str
    category: str
    trend: str  # up, down, stable
    target: float
    last_updated: datetime

class UXMetricsDashboard:
    def __init__(self):
        self.metrics: List[UXMetric] = []
        self.goals: Dict[str, float] = {}
    
    def track_metric(self, metric: UXMetric):
        self.metrics.append(metric)
    
    def set_goal(self, metric_name: str, target: float):
        self.goals[metric_name] = target
    
    def calculate_scorecard(self) -> Dict:
        scores = []
        for goal_name, target in self.goals.items():
            metric = self._get_latest_metric(goal_name)
            if metric:
                achieved = metric.value >= target
                score = (metric.value / target) * 100 if target > 0 else 0
                scores.append({
                    'metric': goal_name,
                    : metric.value,
                    : target,
                    : achieved,
                    : (score, ),
                    : metric.trend
                })
        
        overall_score = (s[]  s  scores) / (scores)  scores  
        
         {
            : overall_score,
            : scores,
            : {
                : (  s  scores  s[]),
                : (scores),
                : (  s  scores  s[] == ),
                : (  s  scores  s[] == )
            }
        }
    
     () -> [UXMetric]:
         (
            (m  m  (.metrics)  m.name == name),
            
        )



UX_METRICS = {
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : ,
    : 
}

Example 3: Design System Documentation

DESIGN_SYSTEM = {
    "principles": [
        {
            "name": "User-Centered",
            "description": "Design decisions prioritize user needs and goals",
            "guidelines": [
                "Every interaction should serve a clear user purpose",
                "Reduce cognitive load through clarity and simplicity",
                "Test assumptions with real users regularly"
            ]
        },
        {
            "name": "Consistent",
            "description": "Similar elements behave similarly across the system",
            "guidelines": [
                "Follow established patterns before creating new ones",
                "Use the design system components first",
                "Document any deviations from patterns"
            ]
        },
        {
            "name": "Accessible",
            "description": "Everyone can use the product regardless of ability",
            "guidelines": [
                "Meet WCAG 2.1 AA standards",
                "Design for keyboard navigation",
                "Provide multiple ways to accomplish tasks"
            ]
        }
    ],
    "colors": {
        "primary": {
            "main": "#007AFF",
            "light": "#5AC8FA",
            "dark": "#0056B3",
            "contrast": "#FFFFFF"
        },
        "secondary": {
            "main": "#5856D6",
            : ,
            : 
        },
        : {
            : ,
            : ,
            : ,
            : 
        },
        : {
            : ,
            : ,
            : 
        }
    },
    : {
        : {
            : ,
            : 
        },
        : {
            : {: , : , : },
            : {: , : , : },
            : {: , : , : },
            : {: , : , : },
            : {: , : , : },
            : {: , : , : }
        }
    },
    : {
        : ,
        : {
            : ,
            : ,
            : ,
            : ,
            : ,
            : ,
            : 
        }
    },
    : {
        : {
            : [, , , ],
            : [, , ],
            : [, , , , ],
            : {
                : ,
                : ,
                : 
            }
        },
        : {
            : [, , , ],
            : [, , ],
            : {
                : ,
                : ,
                : 
            }
        }
    }
}

Best Practices

• Start with user research before designing
• Create and use personas to guide decisions
• Map complete user journeys
• Design for emotions, not just functionality
• Use data to inform design decisions
• Test continuously with real users
• Document design decisions and patterns
• Measure and track UX metrics
• Iterate based on feedback
• Balance user needs with business goals

Core Competencies

• User research and synthesis
• Journey mapping
• Persona development
• Information architecture
• Interaction design
• Visual design
• Prototyping
• Usability testing
• UX metrics and analytics
• Design systems
• Service design
• Design strategy
• Stakeholder alignment
• Workshop facilitation
• Communication and presentation