I’ve been using Cursor for a few months now. The tab completion thing - where it suggests code, deletions, even where to move next - works better than it should. I started noticing I was just pressing tab over and over, not really thinking about it. The system predicted, I confirmed. Predict, confirm. Predict, confirm.

Then I watched a talk by Scott Jenson at Ubuntu Summit 2024. He worked on the original Mac Finder in the 80s, now does open source stuff. His point was that desktop UX hasn’t meaningfully changed in 20 years because Apple and Microsoft stopped leading. There’s nothing left to copy. And so everyone’s just polishing what exists.

He talked about something called learning loops - a concept from game design. Click is boring but consistent. Click-drag builds on click. Double-click builds on that. Each layer adds capability without breaking what came before. Super Mario teaches you to jump, then to time your jump, then to attack - all with one button. The insight is that good interaction design stacks simple gestures into complex behaviors.

The tab thing in Cursor is a loop. A very tight one. Predict, show, confirm. One key. It works because the prediction is good enough and the confirmation cost is almost nothing.

I started wondering what it would feel like if that loop existed outside the code editor.

Tab in a code editor already means “indent” and “next field” - same as anywhere else on desktop. Cursor hijacked it anyway. It works because the prediction is good enough that you don’t miss the old behavior when a suggestion appears. When there’s no suggestion, tab still indents. Tab is still tab, it’s just magically augmented.

The same logic could apply at the OS level. Tab still does what tab does - until the system has a confident prediction. Then it means “yes.”

It could be very handy, especially in moments of transition.

We talk so much about AI and all of the big, exciting things it can build and transform. But here’s something small, frictionless, and surprisingly useful.

Window switches. Menu opens. An app in the foreground requesting something. These are seams where intent becomes legible.

Here’s a situation. I’m in Cursor working on a project. I need to grab an image file from somewhere in my filesystem. I switch to Finder. Now I’m back to hunting - clicking through folders, maybe using Spotlight, typing the filename from memory.

But the system could already know. I’d been referencing that filename in my code. The switch to Finder could surface a suggestion: search for that file. One key to confirm, and I’m there.

A few more seams:

• A file upload dialog is waiting in the browser. You switch to Finder. The system suggests a search filtered to file types the dialog accepts.
• You select text and open the Format menu. The system surfaces the action you’re most likely to take - bold, link, whatever fits the pattern of what you’ve done before in this context.
• You switch from browser to Notes with a URL on clipboard. The system offers to paste it as a titled link.

The system doesn’t need to understand everything. It needs to recognize a handful of high-signal moments and make one good guess.

Jensen made a point about rushing. The most common product mistake, he said, is cramming things in without stepping back. Desktop interactions are subtle. They compound across every app, every day. Getting them wrong is expensive in ways that are hard to see.

The Cursor tab thing works partly because the predictions are scoped. One file, recent edits, clear intent. Desktop is messier, but transitions might be a way to narrow the problem. The moment you switch windows, the system has signal: where you came from, what you had selected, what the destination app is asking for.

The loop structure - predict, show, confirm - feels worth exploring. What would it mean for the system to understand transitions? And what’s the smallest gesture that could mean “yes”?

• How Video Games Inspire Great UX – Scott Jenson’s writeup on learning loops and game design principles
• Are we stuck with the same Desktop UX forever? – Scott Jenson’s Ubuntu Summit 2024 talk
• Super Mario Bros. 3 Level Design Lessons – How games teach mechanics through layered interaction patterns