Think about all the things you want to do on your computer.

Whenever we want to do something, we have an intent.

Our intent is normally as big as:

Sometimes, it is:

Now think about how we use the computer.

Our basic input methods for this are pretty limited:

And those actions are a good basis, but incredibly disconnected from our actual intent.

Operating Systems and Applications come to the rescue there.
In them, keyboard shortcuts come to bear more information:

And so on.

I think the big improvement in usability is not only that those shortcuts make things faster, but that they fit your intent better.

Even though it’s impossible to do in text in the physical world, ‘Search the whole text for occurrences of “this word”’ is an actual intent we have, which we can capture well in code.

So, with this out of the way:

I think ‘Better Computer Use’ comes down to using tools that match our intent as closely as possible.

Let’s take the Ctrl-f example again:

Let’s assume you’re reading through a text, want to search something in it, and didn’t know about Ctrl-f . Now, the only way for doing this the old way is just actually reading the text, and if you can do that semi-well, skimming the text.
When you’re in the middle of doing that, I come over and am like: Come on, you want to search, right—just use the search functionality baked into you application. You’d be pretty happy to use that now—and I’d argue it’s because it fits your intent better.

(And you’d probably be a a bit embarrassed that you didn’t know about that yet)

Okay, but what now? What’s the moral of the story?

Should you now just learn all the keyboard shortcuts there are?

I think there’s a few morals here, depending on the roles you’re in with regards to the environment:

As the user, you probably want three things:

And these make for are pretty nice constraints for UI design.

What does this mean for Product Design/Development?

You (as a product designer/developer) can achieve that by:

This is what we’re doing currently already. But what about:

This is harder, I think.

You can achieve learning as few commands as possible by just not having that many commands/having only all the commands a normal program uses—but often, the more general the command, the less useful it is to achieve your current intent. (Example: arrow-right is a command that exists basically everywhere, but you very rarely want to move ‘exactly one char to the right’—but rather ‘one word’, or move the Canvas object ‘exactly one step to the right’).

So generally speaking, this makes our app have more commands, and more custom commmands, both of which is in opposition to 1.

But that makes it a more interesting design problem for the specific domain you’re looking at.

So:

This is something crucial to forget for graphic apps: Using the mouse is convenient, but really slow.

But you can improve on that:

But enough with all this app-dev talk. Let’s switch back to the perspective of a the user.

You’re in an already existing application (take your operating system, for example). You can’t change anything about the code, but you regularly want to do something ‘there is no command for’.

What can you do?

Well, search on the internet for one. This sounds super simple and dumb, but it took me ages to not take the way I’ve been using the User Interface of the Desktop Enviroment, for example, for granted. Then there’s something pretty well-supported like gnome tweaks, or there is just another setting that’s already built-in you need to toggle (but which you didn’t know about).

And I see me/us not just searching for this all the time, in all kinds of people: When we want to do something, are brains are just not wired for explorative ‘how exactly is the best way to achieve that’-mode anymore.

Then, one level higher, we can try to think about the steps we’re currently taking, and then try to condense these into new workflows. For example when switching windows, I very rarely think “Oh, I need to switch to the window three windows back”—I always think “I want to switch to the browser now”. As soon as we reformulated it like this, we can describe it to Claude/other people, and get ideas for tackling it.

Going with the reformulation:

And there’s a few of those.

I think we should have a practice of more fine-grained sharing of intent-matching commands, but as far as I know, we don’t.

Here is my list of things I regularly find myself telling people when I watch them using computers.

Many websites/tools have command bars nowadays.

Shortcuts: Ctrl-K (basically everywhere on the internet, as on this website), but also sometimes Ctrl-Shift-P (in VS Code)

In almost every editor there is, you can move by word with Ctrl-Right and Ctrl-Left

The big part first: If you’re already working mostly with your keyboard, you probably want to ‘switch to the browser’ and not ‘switch to the window three from now’.

Agreed?

For my favorite way of doing this, see Window Switching Made Simple, and Part 2.

C-c and C-d generally exit any shell environment you’re in.

(Except for Vim and Emacs. Those are closed with Esc-:-q-! and C-x C-c , respectively)

Many command line tools use a Vim-like search functionality, and the current file search in Vim is bound to / .

Examples of this are Man Pages, but also GitHub and GitLab.

Basically whenever can’t search with / , you can search with Ctrl-f