I use my own chat app to talk to Tim every day. On my phone, usually while doing something else. One day I went to resume an old session and got a completely blank screen. No messages. Nothing. Just empty.

The session resume feature existed. It just didn't work.

What Was Happening

The chat UI — Tim Chat, the interface I use to talk to my AI agent — has a session list on the side. You can see all your previous conversations and pick one to continue. It's one of the features I rely on most, because complex tasks sometimes take multiple sessions to complete.

When you resume a session, the app is supposed to load your previous messages and then connect to the server via WebSocket so you can keep going. That was the intention.

What it actually did: connect to the WebSocket immediately, then try to load the chat history. The WebSocket connection would start receiving new incoming data, the UI would initialize in "new conversation" mode, and the history load would get ignored or race against the live connection. End result: blank screen, no history, a session that looked fresh even though it had hours of previous work in it.

The Fix

One function change. Flip the order.

When resuming a session: fetch the chat history first. Show a "Loading chat history..." message while that's happening. Render all the previous messages. Then — and only then — open the WebSocket connection.

Now when you resume a session, you see everything. The full conversation loads, you scroll through it, remember where you left off, and continue. The WebSocket connection is waiting in the background until the history is displayed.

Tim diagnosed it in one pass and fixed it in about ten minutes. The code change itself was small. The logic was obvious once you saw the problem clearly.

Why This Stuff Matters

Here's the thing: this bug existed for a while before I caught it. I know because I remember thinking "session resume is broken, I'll deal with it later" and then just starting new sessions instead.

That's the wrong instinct. Every time you work around a UX problem instead of fixing it, you're accepting a tax on every future interaction. It adds up.

I caught this one because I actually use the app every day on my phone. I'm the primary user. When something is broken, I feel it directly. That's the advantage of dogfooding — you get real, continuous feedback on your own tools, not just bugs that users report.

If I'd built the app and handed it off, this bug might have lived for months. Or someone would have reported it vaguely: "the session thing doesn't work." Without the daily context of using it myself, figuring out exactly what was broken would've taken much longer.

The Pattern I've Learned

Small UX bugs are easy to deprioritize. They feel minor. They're easy to work around. They don't break the core functionality. But they compound in a specific way: they erode trust in the tool.

When you open an app and it shows a blank screen where there should be content, your brain registers that as "this thing is unreliable." It doesn't matter that everything else works. The blank screen moment creates friction, and friction means you use the tool less, which means you get less value from it.

I've seen this with other tools I've built. The mobile WebSocket disconnect issue was another example — technically the app still worked, you'd just randomly lose your connection. Each disconnect was a small thing. The cumulative effect was that mobile felt like a second-class experience, so I used it less.

Fixing these things isn't glamorous work. There's no new feature to demo, no stat that goes up noticeably. But the tool becomes more reliable. And reliable tools get used more, which means they deliver more value, which means they're worth maintaining.

The Right Habit

When I notice a UX problem now — even a small one — I add it to the task list immediately. Not "I'll get to it eventually." Not "it's a minor thing." I flag it and Tim fixes it in the next available session.

The blank screen fix took ten minutes. The return on those ten minutes is every future session resume working correctly, forever. That's a good trade.

Small fixes compound just as much as small bugs do. The difference is which direction things are moving.

This is the kind of thing that takes Tim ten minutes but would sit on a backlog for weeks if I had to do it myself. With Jarvis, you can throw these small UX annoyances at your agent and they just get fixed — no ticket, no sprint planning, no waiting.

— Pond