The Hermeneutic Spiral in UX Design

Consider a typical creative marketplace intake flow:

The system treats Session 2 identically to Session 1. All context is lost. The user must re-establish everything.

Why This Fails

From a UX perspective, this creates friction:

• Time waste: Users repeat information they've already provided
• Trust erosion: "Didn't I tell you this last time?"
• Cognitive load: Re-articulating preferences requires mental effort
• Relationship regression: Each session restarts the relationship

But the deeper problem is philosophical. The system fails to understand the user in Heidegger's sense of the term.

The Circle of Understanding

In Being and Time, Heidegger describes understanding as fundamentally circular:

"Any interpretation which is to contribute understanding, must already have understood what is to be interpreted."

This isn't a logical flaw—it's the structure of comprehension itself. We understand parts through the whole, and the whole through its parts. Each cycle deepens our grasp.

The Spiral, Not the Circle

While Heidegger uses "circle," the motion is better described as a spiral. Each iteration doesn't return to the same point—it advances understanding:

The key insight: understanding accumulates. It doesn't reset.

Application to User Experience

Traditional systems break this spiral:

A hermeneutic system retains context and asks only what has changed.

Core Principles

The Hermeneutic Spiral pattern follows three principles:

Conversational Flow

First Visit:

Return Visit (recognized by phone number):

The second conversation is shorter, more natural, and acknowledges the relationship history.

System Overview

The Abundance Network is a WhatsApp-based creative professional matching platform built for Half Dozen. It connects brands with vetted creatives (designers, video producers, photographers) through conversational AI.

• Channel: WhatsApp (phone number as identity)
• Interaction: Conversational (not form-based)
• Memory: Cloudflare KV for context persistence
• Matching: LLM-driven creative recommendation

Architecture

Context Schema

interface UserContext {
  // Identity (stable)
  phone_number: string;
  name?: string;

  // Brand context (semi-stable)
  brand?: string;
  industry?: string;
  style_preferences?: string[];

  // Project history (accumulates)
  past_requests: ProjectRequest[];

  // Interaction state (session-specific)
  current_conversation_stage: string;
  pending_matches?: Creative[];

  // Hermeneutic metadata
  first_interaction: string;
  total_sessions: number;
  last_seen: string;
}

Delta Detection Logic

function determineQuestions(context: UserContext): Question[] {
  const questions: Question[] = [];

  // Never ask what we already know (stable fields)
  if (!context.name) {
    questions.push({ field: 'name', prompt: "What's your name?" });
  }

  if (!context.brand) {
    questions.push({ field: 'brand', prompt: "What brand are you with?" });
  }

  // Always ask what varies (project-specific fields)
  questions.push({
    field: 'need',
    prompt: context.brand
      ? `What does ${context.brand} need this time?`
      : "What kind of creative help do you need?"
  });

  // Offer to reuse if we have history
  if (context.past_requests.length > 0) {
    const lastBudget = context.past_requests[0].budget;
    questions.push({
      field: 'budget',
      prompt: `Similar budget to last time (${lastBudget})?`,
      default: lastBudget
    });
  } else {
    questions.push({
      field: 'budget',
      prompt: "What's your budget range?"
    });
  }

  return questions;
}

Comparing stateless vs. hermeneutic intake:

The hermeneutic approach halved the interaction length for returning users while improving satisfaction.

What to Remember, What to Ask

Not all context should persist. The key distinction:

Graceful Degradation

// If context is partial, acknowledge and ask
if (context.name && !context.brand) {
  return `Hi ${context.name}! I don't have your brand on file—
          what are you working on?`;
}

// If context might be stale, offer to update
if (daysSince(context.last_seen) > 90) {
  return `Welcome back, ${context.name}! It's been a while.
          Still with ${context.brand}?`;
}

For UX Design

The Hermeneutic Spiral suggests that good UX isn't just about reducing friction in a single session—it's about building understanding across sessions. Design should treat user relationships as ongoing conversations, not isolated transactions.

For AI Systems

Conversational AI systems benefit from persistent context:

System: You are matching creatives with brands.

User context:
- Name: Louis
- Brand: Sunset Sounds
- Previous requests: Album artwork ($3,000), satisfied
- Style preference: organic, earthy

Current request: Music video

Use this context to personalize recommendations.

For Privacy

Context persistence raises privacy considerations:

• Users should be able to view and delete their context
• Sensitive fields should have explicit consent
• Context should expire if unused (configurable TTL)
• GDPR/CCPA compliance requires clear data handling

This section translates the Hermeneutic Spiral pattern into concrete implementation steps. The pattern works for any conversational system with persistent user context— chatbots, intake forms, onboarding flows, or customer service tools.

Step-by-Step Process

Step 1: Identify Stable vs. Variable Fields (Human)
Categorize user information by persistence:
- Stable: Identity, brand, organization, preferences (persist forever)
- Semi-stable: Contact info, team members, budget range (confirm if stale)
- Variable: Current need, timeline, specific requirements (ask each time)

Step 2: Implement Context Schema (Agent)
Create a schema that captures:
- User identity (phone, email, or auth token)
- Stable fields (name, brand, industry, style preferences)
- Session history (past requests, timestamps, outcomes)
- Interaction metadata (first_seen, total_sessions, last_seen)
Store in KV, database, or session storage based on scale.

Step 3: Build Delta Detection Logic (Agent)
Write a function that determines what to ask:
- Skip questions for fields we already know
- Confirm semi-stable fields if stale (>90 days)
- Offer previous values as defaults when applicable
- Always ask for variable fields (current need, budget)

Step 4: Design Conversational Flow (Human)
Create two conversation paths:
- First-time: Full intake (name, brand, preferences, need)
- Returning: Context-aware ("Welcome back, [name]! Still with [brand]?")
Ensure returning flow feels natural, not robotic.

Step 5: Add Graceful Degradation (Agent)
Handle partial context gracefully:
- If name exists but brand missing: "Hi [name]! What are you working on?"
- If context is stale: "Still with [brand]? Anything changed?"
- If fields conflict: Ask for confirmation rather than assuming

Step 6: Test Context Persistence (Human)
Validate that context survives:
- Session boundaries (page refresh, browser close)
- Component remounting (React/Svelte/Vue lifecycle)
- Authentication flows (login/logout)
- Multi-device access (phone → desktop)

Real-World Example: Customer Support Chatbot

Let's say you're building a support chatbot for a SaaS product:

interface UserContext {
  // Stable (persist forever)
  user_id: string;
  name: string;
  company: string;
  plan: 'starter' | 'pro' | 'enterprise';
  industry?: string;

  // Semi-stable (confirm if >90 days)
  contact_email?: string;
  contact_phone?: string;
  preferred_language?: string;

  // Session history (accumulates)
  past_tickets: Array<{
    issue_type: string;
    resolved: boolean;
    created_at: string;
  }>;

  // Metadata
  first_interaction: string;
  total_sessions: number;
  last_seen: string;
}

function buildConversation(context: UserContext): Message[] {
  const messages: Message[] = [];

  // First-time flow
  if (!context.name) {
    messages.push({ text: "Hi! I'm here to help. What's your name?" });
    return messages;
  }

  // Returning flow
  const greeting = `Welcome back, ${context.name}!`;

  // Check for repeated issues
  const recentTickets = context.past_tickets.filter(
    t => Date.now() - new Date(t.created_at).getTime() < 7 * 24 * 60 * 60 * 1000
  );

  if (recentTickets.some(t => !t.resolved)) {
    messages.push({
      text: `${greeting} I see you have an open issue. Want to follow up on that?`
    });
  } else {
    messages.push({
      text: `${greeting} How can I help you today?`
    });
  }

  return messages;
}

First interaction:

Bot: Hi! I'm here to help. What's your name?
User: Sarah
Bot: Nice to meet you, Sarah! What company are you with?
User: Acme Corp
Bot: Got it. What issue can I help you with?
User: Users can't log in
Bot: Let me create a ticket for login issues...

Return interaction (1 week later):

Bot: Welcome back, Sarah! I see you have an open issue about login problems.
     Want to follow up on that?
User: Yes, is it fixed?
Bot: Let me check the ticket status...
     [Checks ticket #1234]
     Yes! Our team resolved it yesterday. Login should work now.
     Are you still experiencing issues?
User: No, it's working. Thanks!
Bot: Great! Anything else I can help with?

Notice: The bot remembered Sarah's name, company, and open ticket. The conversation feels continuous, not like starting over.

When to Use the Hermeneutic Spiral

Use this pattern when:

• Multi-session interactions: Users return multiple times over weeks/months
• Identity is consistent: Phone number, email, or auth token persists
• Context accumulates value: Past interactions inform future ones
• Reduced friction matters: Saving 30 seconds per session adds up
• Relationship-driven: You're building a service, not a one-off transaction

Don't use for:

• One-time interactions (contact forms, surveys)
• Anonymous users where identity can't persist
• High-security contexts where caching user data is risky
• Exploratory conversations where context doesn't help

Privacy and Data Handling

Context persistence raises privacy considerations. Implement safeguards:

The Hermeneutic Spiral respects user time while respecting user privacy. Persistent context should feel helpful, not invasive. Test with real users to calibrate.

The Hermeneutic Spiral transforms user intake from repetitive interrogation into evolving conversation. By applying Heidegger's insight that understanding accumulates through iteration, we can design systems that respect user time and build genuine relationships.

The key is simple: remember what you learn, ask only what's new.

This isn't just efficient—it's philosophically correct. Understanding is circular, not linear. Each interaction should deepen the spiral, not restart it.