Agentic UX Design - Relationship-Centric Interfaces: Claude Code skill

---
name: Agentic UX Design - Relationship-Centric Interfaces
description: Design AI-first interfaces that build ongoing relationships through memory, trust evolution, and collaborative planning, not just isolated screen interactions
when_to_use: when user explicitly requests agentic UX design, relationship-centric design, or mentions designing for memory, trust evolution, or long-term user relationships; ONLY use when specifically asked, not for general UI/UX tasks
version: 1.0.0
---

# Agentic UX Design - Relationship-Centric Interfaces

## Overview

**The paradigm shift from screen-centric to relationship-centric design.**

Traditional UX optimizes individual screens and isolated interactions. Agentic UX designs for ongoing relationships where systems learn, remember, and evolve alongside users across sessions, devices, and contexts.

**Core principle:** Every interaction builds on learned preferences and user history. Systems don't just respond—they develop understanding that compounds over time.

**Announce at start:** "I'm using the Relationship Design skill to create an agentic, memory-aware interface that builds long-term relationships with users."

## When to Use

Use this skill when:
- Designing AI-powered applications, chatbots, or agent systems
- Building interfaces with repeated user interactions over time
- Creating systems that should learn from user behavior
- Rethinking traditional dashboards or SaaS products for the AI era
- Users complain about "starting over" every session
- You need to measure relationship quality, not just conversion rates
- Designing for trust evolution from transparency to autonomy
- Building collaborative planning features (human + AI co-creation)

**When NOT to use:**
- Simple one-time transactions with no user accounts
- Static content websites with no personalization needs
- Systems where memory/learning creates privacy concerns
- Interfaces where consistency > adaptation (e.g., medical equipment)

## The Five Pillars of Agentic UX

### 1. Memory Revolution: From Static Preferences to Contextual Intelligence

**Old model:** Store static preferences (theme: dark, language: EN)

**New model:** Maintain dynamic, evolving relationship models

**Design for:**
- **Behavioral patterns:** Not just "user clicked X" but "user spends 20 min frustrated searching for Y on Tuesday evenings"
- **Emotional context:** Recognize frustration, urgency, exploration, decision-making modes
- **Temporal evolution:** How preferences change over weeks/months
- **Cross-session continuity:** Seamless continuation across devices and time

**Key question:** What would this experience look like if it remembered everything and got better over time?

### 2. Trust as a Design Material: The Three-Stage Evolution

Design interfaces that earn autonomy through graduated trust:

**Stage 1: Transparency Phase**
- Show all reasoning, decision processes, confidence levels
- Explain why the system suggests actions
- Reveal data sources and logic paths
- User wants to see everything

**Stage 2: Selective Disclosure Phase**
- Show reasoning only for important/uncertain decisions
- Quiet confidence for routine actions
- System learns when to show work vs. act confidently
- User trusts but verifies

**Stage 3: Autonomous Action Phase**
- Act independently with subtle confirmation patterns
- Clear escalation paths for mistakes
- User delegates entire decision categories
- Trust through consistent, aligned behavior

**Design patterns:**
- Progressive disclosure controls (let users adjust transparency level)
- Confidence indicators (system certainty visualization)
- Trust recovery protocols (clear undo/correction paths)
- Explain-on-hover for autonomous actions

**Key question:** How might users develop trust with this system gradually?

### 3. Relationship-Centric Architecture

**Design ongoing partnerships, not isolated transactions.**

**From:** User logs in → completes task → logs out → system forgets

**To:** System maintains continuous awareness of:
- User's ongoing goals and projects
- Communication preferences and patterns
- Learning from what works for this individual
- Relationship depth over time

**Implementation patterns:**
- **Memory visualization:** Show what system remembers (preferences, goals, patterns)
- **Context indicators:** Subtle cues showing how past interactions influence current suggestions
- **Forgetting controls:** User agency over what gets remembered vs. forgotten
- **Relationship timeline:** Visual representation of how the relationship evolved

**Key question:** What goals are users really trying to achieve, and how could an agentic system help them get there more effectively?

### 4. Systems That Plan Their Own Path

**From:** Design every possible user path explicitly

**To:** Design goal-alignment mechanisms where system dynamically constructs paths

**Agentic systems:**
- Maintain awareness of underlying user objectives
- Adapt interaction patterns based on what works
- Learn from imperfect demonstrations and natural language feedback
- Construct custom workflows for individual users

**Design for:**
- **Goal continuity:** Persistent awareness of user objectives across sessions
- **Proactive nudging:** Gentle next-step suggestions without intrusion
- **Collaborative planning:** Human + AI jointly developing approaches
- **Adaptive interfaces:** UI elements that evolve based on usage patterns

**Key question:** Can the system help users achieve goals they haven't fully articulated yet?

### 5. New Success Metrics: Beyond Conversion Rates

Traditional UX metrics (session duration, conversion rates, clicks) miss the point for agentic experiences.

**Measure instead:**

**Relationship Quality**
- Trust scores and delegation comfort
- User confidence in system decisions
- How often users second-guess the system
- Comfort with autonomous actions

**Compounding Value**
- Experience improvement over time
- Increasingly complex problems solved
- Better outcomes through accumulated understanding
- Month 6 vs. Month 1 comparison

**Context Accuracy**
- System understanding of intent and preferences
- Alignment with user values and goals
- Situational needs recognition
- Prediction accuracy for important decisions

**Democratic Alignment**
- Alignment with broader human values
- Socially acceptable behavior boundaries
- Ethical decision-making
- Collective constitutional principles

**Key question:** How do we know if the relationship is getting better, not just more frequent?

## The Relationship Design Process

### Phase 1: Understand the Relationship Context

Ask these questions:

1. **Relationship duration:** How long do users typically engage? (days, months, years?)
2. **Interaction frequency:** Daily? Weekly? Sporadic?
3. **Goal complexity:** Simple tasks or evolving, complex objectives?
4. **Trust requirements:** What level of autonomy makes sense?
5. **Memory sensitivity:** What should system remember vs. forget?
6. **Personalization depth:** How much should experience adapt?

### Phase 2: Map Trust Evolution

For your specific use case:

1. **Define transparency needs:** What must always be explained?
2. **Identify routine actions:** What can become autonomous over time?
3. **Design trust indicators:** How will users see system confidence?
4. **Create recovery paths:** What happens when system makes mistakes?
5. **Plan trust checkpoints:** How do users adjust autonomy levels?

### Phase 3: Design Memory Architecture

1. **Behavioral data:** What patterns matter?
2. **Preference evolution:** What changes over time?
3. **Context signals:** What indicates user's current state/goal?
4. **Memory controls:** How do users manage what's remembered?
5. **Cross-session continuity:** How does system maintain context?

### Phase 4: Build Collaborative Planning Patterns

1. **Goal capture:** How does system learn user objectives?
2. **Proactive suggestions:** When/how does system offer help?
3. **Co-creation interface:** How do human + AI work together?
4. **Adaptive UI:** What interface elements should evolve?
5. **Learning feedback:** How do users correct system understanding?

### Phase 5: Define Success Metrics

Choose 2-3 metrics from each category:
- Relationship Quality indicators
- Compounding Value measures
- Context Accuracy signals
- Democratic Alignment guardrails

Track these over weeks/months, not just sessions.

## Design Patterns Library

### Memory-Aware Interface Components

**Contextual Timeline**
- Show user's journey over time
- Highlight preference evolution
- Display key relationship moments

**Emotional State Indicators**
- Recognize frustration, urgency, exploration
- Adapt interface based on detected state
- Show system's understanding of context

**Dynamic Suggestions Panel**
- Based on current goal + historical patterns
- Confidence indicators for each suggestion
- Explain why these suggestions now

### Trust-Building Components

**Reasoning Display (Transparency Phase)**
- Show decision logic
- Display confidence levels
- Reveal data sources

**Confidence Meter**
- Visual indicator of system certainty
- Hover to see reasoning
- Adjust autonomy based on confidence

**Undo/Correct Patterns**
- One-click correction of autonomous actions
- System learns from corrections
- Clear escalation paths

### Collaborative Planning Components

**Goal Dashboard**
- Ongoing objectives visualization
- Progress indicators
- System suggestions for next steps

**Planning Canvas**
- Human + AI co-create plans
- System contributes capabilities
- User provides judgment and strategy

**Preference Evolution Map**
- Show how system's understanding improved
- User control over what's learned
- Forgetting controls

## Common Mistakes

### ❌ Treating Memory Like Static Settings
**Problem:** Storing preferences as key-value pairs (theme: dark) instead of evolving patterns

**Fix:** Design dynamic models that understand behavioral patterns, temporal context, and evolution over time

### ❌ Binary Trust Model
**Problem:** System is either fully transparent or fully autonomous from day one

**Fix:** Design three-stage trust evolution with gradual autonomy and user-controlled trust levels

### ❌ Using Traditional UX Metrics
**Problem:** Measuring session duration and conversion rates for relationship-based systems

**Fix:** Track relationship quality, compounding value, context accuracy over weeks/months

### ❌ Forgetting Privacy Controls
**Problem:** System remembers everything with no user control

**Fix:** Build forgetting controls, memory visualization, and clear data retention policies

### ❌ Designing Screens Instead of Relationships
**Problem:** Focusing on pixel-perfect interfaces without relationship architecture

**Fix:** Start with relationship model, then design screens that support ongoing partnership

### ❌ No Trust Recovery Path
**Problem:** When system makes mistakes, users lose all trust permanently

**Fix:** Design clear correction paths, system learning from mistakes, and trust recovery protocols

## Real-World Applications

**See [EXAMPLES.md](EXAMPLES.md) for:**
- EU B2B relationship cockpit (automotive service networks)
- Memory-aware content discovery (streaming services)
- Collaborative planning assistant (project management)
- Trust-evolving financial advisor

**See [REFERENCE.md](REFERENCE.md) for:**
- Detailed research foundation (DeepMind, Anthropic, OpenAI)
- Technical implementation patterns
- Memory architecture designs
- Metrics implementation guides

**See [CHECKLIST.md](CHECKLIST.md) for:**
- Relationship UX audit checklist
- Memory & data contracts sprint guide
- Trust evolution design worksheet

## Quick Reference

| Traditional UX | Agentic UX |
|----------------|------------|
| Session duration | Relationship depth over months |
| Conversion rates | Trust scores and delegation comfort |
| Click-through rates | Compounding value (Month 6 vs Month 1) |
| Isolated screens | Continuous relationship context |
| Static preferences | Dynamic pattern evolution |
| One-size-fits-all | Individually adaptive interfaces |
| Explicit navigation | Goal-aligned path construction |
| Binary permissions | Graduated trust evolution |

## Remember

- Design for relationships that span months, not sessions
- Trust evolves through three stages: Transparency → Selective → Autonomous
- Memory means understanding patterns, not storing static preferences
- Measure relationship quality, not just engagement metrics
- Systems should plan paths to goals, not just execute predefined flows
- User control over memory, trust levels, and autonomous actions is essential
- Privacy and forgetting are as important as memory and learning

**The screens will always matter. But the relationships matter more.**