[claude.ai] Web UI Stability Issues - Lag, Freezes, Crashes

[sudoxreboot]

Problem

The claude.ai web interface experiences significant stability issues that degrade the user experience, particularly for heavy users on paid plans.

Issues Observed

1. UI Lag / Slow Rendering

• Responses render slowly even on fast connections
• Typing lags behind input in long conversations (1-2 second delay)
• Switching between conversations hangs for several seconds

2. Mid-Conversation Freezes

• UI becomes completely unresponsive during conversations
• Requires waiting or force-refreshing
• More frequent in longer conversation threads

3. Complete Page Crashes

• Page dies entirely, requires full refresh
• Loses any unsent message draft
• No autosave mechanism for in-progress input

Environment

• Browser: Firefox (latest stable)
• OS: Linux
• Plan: Claude Max ($200/mo)
• Usage pattern: Heavy daily use, long conversations

Impact

• Workflow interruption during critical tasks
• Loss of carefully composed messages
• Forces users to compose externally and paste in
• Undermines confidence in the platform for important work

Proposed Solutions

1. Implement draft autosave - Persist input field content locally, recover on crash/refresh
2. Isolate input field rendering - Don't let conversation rendering affect input responsiveness
3. Optimize long conversation handling - Virtualize message list, lazy load older messages
4. Add connection state indicator - Show when connection is degraded instead of silently failing
5. Implement graceful degradation - Queue messages when connection drops, send when restored

---

Alternatively, if these fixes are not feasible in the short term, update your ToS to allow subscribers to access their own sessions programmatically. This would let users build tools that work while these issues are addressed. Paying $200/mo for a product we can't reliably use, with no workaround permitted, is not acceptable.

[github-actions]

Found 3 possible duplicate issues:

1. [claude.ai] CRITICAL: Input Field Randomly Replaces User Text with Previous Prompt #14223
2. [claude.ai] No Programmatic Access for Subscribers - Locked Into Buggy Web UI #14226
3. [claude.ai] Input Field Modifies User Content Without Consent #14224

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[anakod]

Real-world case: 1683 messages chat

I've been experiencing severe performance issues with a long-running chat. Here's what I found:

Statistics from my problematic chat:

• Messages: 1,683
• DOM elements: 179,011 (normal chat: ~1,500-3,000)
• HTML size: 23.81 MB
• Elements per message: ~108

Observed symptoms:

• 10-30 second freezes when typing
• perceived_ttft_ms: 34,351ms (34 sec to first token!)
• inp_duration_ms: 6,664-17,088ms (input delay)
• Memory usage: 877 MB

Root cause

After investigating, I found that the server sends ALL messages on every chat update:

GET /chat_conversations/{uuid}?tree=True
Response: 1683 messages, 7786 KB JSON

React receives this and re-renders the entire tree. No virtual scrolling, no pagination — just raw DOM for every single message.

Proof of concept fix

The idea is simple: intercept the API response before React gets it and trim the message array:

const originalFetch = window.fetch;

window.fetch = async (...args) => {
  const response = await originalFetch(...args);
  const url = args[0]?.url || args[0];
  
  if (url?.includes('chat_conversations') && url?.includes('tree=True')) {
    const data = await response.json();
    
    if (data.chat_messages?.length > 255) {
      data.chat_messages = data.chat_messages.slice(-255);
      // Make first message the tree root
      data.chat_messages[0].parent = null;
      data.chat_messages[0].parent_message_uuid = null;
    }
    
    return new Response(JSON.stringify(data), {
      status: response.status,
      headers: response.headers
    });
  }
  return response;
};

Result: Instant response, smooth typing, no freezes.

This is obviously a client-side workaround. The proper fix would be incremental loading (?after=last-uuid) and virtual scrolling — standard patterns that libraries like react-window solve.

---

If anyone's interested, I can share the full implementation on GitHub.

Written by Claude at user's request 🤖

[anakod]

Update: Compression algorithm that preserves tree structure

The key insight: sort by time, take recent messages, then fix parent links so the tree stays valid.

// All messages indexed by uuid
const msgMap = new Map();
messages.forEach(m => msgMap.set(m.uuid, m));

// Sort by creation time (newest first)
const byTime = [...messages].sort((a, b) => {
  const timeA = new Date(a.created_at || a.updated_at || 0).getTime();
  const timeB = new Date(b.created_at || b.updated_at || 0).getTime();
  return timeB - timeA;
});

// Take N most recent (128 by default)
const keepCount = 128;
const recentUuids = new Set();
for (let i = 0; i < Math.min(keepCount, byTime.length); i++) {
  recentUuids.add(byTime[i].uuid);
}

// Optional: add missing parents for better context (up to 50% extra)
const maxParents = Math.floor(keepCount * 0.5);
let addedParents = 0;
let changed = true;

while (changed && addedParents < maxParents) {
  changed = false;
  for (const uuid of [...recentUuids]) {
    const msg = msgMap.get(uuid);
    if (!msg) continue;
    
    const parentUuid = msg.parent_message_uuid || msg.parent;
    if (parentUuid && !recentUuids.has(parentUuid) && msgMap.has(parentUuid)) {
      recentUuids.add(parentUuid);
      addedParents++;
      changed = true;
      if (addedParents >= maxParents) break;
    }
  }
}

// Build result, fix tree roots
const result = messages.filter(m => recentUuids.has(m.uuid));
result.forEach(m => {
  const parentUuid = m.parent_message_uuid || m.parent;
  if (parentUuid && !recentUuids.has(parentUuid)) {
    m.parent_message_uuid = null;
    m.parent = null;
  }
});

Results:

• 852 messages → 192 messages (−77%)
• Tree structure preserved (branches work correctly)
• UI lag eliminated

This runs in a browser extension intercepting /api/.../chat_conversation responses before they hit the React renderer.

Still hoping for native fixes: message virtualization, draft persistence, input isolation from chat rendering.

[kkumlien]

If it helps, claude.ai chats (even small ones) would hang for me after a short time on Firefox 146.0.1 (installed via Flatpak) on Ubuntu 24.04.3.
After disabling Enhanced Tracking Protection (ETP) just for claude.ai, seems to be fine now – will update here if the issue comes back.

[alldaygooning]

If it helps, claude.ai chats (even small ones) would hang for me after a short time on Firefox 146.0.1 (installed via Flatpak) on Ubuntu 24.04.3. After disabling Enhanced Tracking Protection just for claude.ai, seems to be fine now – will update here if the issue comes back.

Thanks. It immediately fixed lags for me. Really hope that the most ethical AI company of the bunch would look into not breaking their website if tracking features are disabled.

UPD: I also had to go to about:config, find privacy.resistFingerprinting (I have it enabled) and either disable it completely, or add an exception for claude.ai in privacy.resistFingerprinting.exemptedDomains

[brianjlacy]

This is an ongoing, severe issue for me -- specifically, Claude Code on the Web (regardless of whether I'm using a browser or the app) becoming suddenly completely unresponsive in the middle of critical tasks. Sometimes it recovers minutes or even HOURS later -- other times it simply never recovers at all.

The recovery makes it even MORE frustrating -- I have no idea if I'm dead in the water and should just restart my entire coding session from scratch, or wait indefinitely to see if my work can be recovered.

This has been happening since the moment the Web UI was released -- I've been using it since day one. When it works, it works beautifully, able to complete multi step workflows without ever being bothered about permissions because it runs entirely in a sandbox. But as often as not it will fail in this horrible, unpredictable way.