Hotkeys: Why Power Users Love Our Interface

Your hands are on the keyboard. You're reviewing a 47-file PR. You see the next file you need to check. Do you reach for the mouse, move the cursor, click, wait for the scroll... or do you just press L?

Power users press L.

And they never go back.

The Philosophy: Hands Stay on the Keyboard

Here's the thing about power users: they've done the math. They know that reaching for the mouse takes time. Not much—maybe half a second. But multiply that by 20 files in a PR, 5 PRs a day, 5 days a week.

That's 250 context switches per week just to move a cursor.

Power users don't tolerate this. They learned Vim bindings. They memorized VS Code shortcuts. They configured their terminal to match their brain's speed.

So when they hit a code review tool that forces them to click through everything? They leave.

Why Hotkeys Matter More Than You Think

It's not just about speed. It's about flow state.

1. Context Switching Kills Cognition

When you're deep in code review, your working memory is holding:

• The architecture of the system
• What changed in this PR
• What you just reviewed in the last file
• What you're looking for in the next file

Every time you reach for the mouse, your brain shifts from "review mode" to "navigation mode." It's a tiny interruption, but it breaks the flow.

Hotkeys keep you in one mode: thinking about code.

2. Muscle Memory is Faster Than Conscious Thought

After a day of using H/L navigation, your fingers just know. You don't think "I want to go to the next file." Your hand just moves. It's the same reason Vim users are so productive—muscle memory is pre-cognitive.

We designed our hotkeys to match patterns you already know:

• H/L — Vim-style navigation (left/right for previous/next file)
• GG — Jump to first (classic Vim)
• G — Jump to last (classic Vim)
• Space — Mark reviewed and advance (like Gmail's archive)
• W — Toggle whitespace (mnemonic: "whitespace")
• M — Toggle bookmark (mnemonic: "mark")
• N — Add note (mnemonic: "note")

You're not learning a new system. You're using patterns you already internalized from Vim, Gmail, and other keyboard-first tools.

3. Keyboard Shortcuts Scale With Expertise

Beginners use the mouse. That's fine. Our UI works perfectly with clicks.

But as you review more PRs, you naturally start asking: "Is there a faster way?" That's when you discover H/L. Then GG/G for jumping. Then Space for quick review. Then you're flying.

The interface doesn't get in your way as you level up. It accelerates you.

The Details That Make It Work

Building good hotkeys isn't just mapping keys to actions. It's thinking through the entire experience.

Visual Feedback

In the demo above, notice what happens when you press a key. The hotkey reference highlights. The UI responds instantly. You see that your action registered.

This isn't decoration—it's confirmation. Especially when you're learning, you need to know the hotkey worked before you've memorized the muscle pattern.

No Accidental Triggers

We chose keys carefully to avoid conflicts:

• No letter keys used by browser shortcuts (T for new tab, N for new window, etc.)
• Modal-aware: typing in a comment box doesn't trigger navigation
• Escape always closes, everywhere

Nothing worse than pressing J to type a comment and accidentally jumping to the next file.

Discoverable But Not Intrusive

We show the hotkey reference inline—you saw it in the demo. But it's not blocking your view. You can ignore it entirely and click through the UI. Or glance at it once, try J, and never need the mouse again.

Who This Is For

Hotkeys aren't for everyone. And that's okay.

If you review 1-2 PRs a week casually, clicking is fine. You don't need to optimize milliseconds. Our mouse-driven UI works great for you.

But if you're:

• A senior engineer reviewing 10+ PRs per week
• A maintainer triaging contributions on large open-source projects
• An architect reviewing critical infrastructure changes
• Someone who learned Vim and can't go back to slow editors

...then you feel the difference. Hotkeys aren't a nice-to-have. They're table stakes.

What's Next: Customization

We're working on letting you rebind hotkeys. Because power users don't just want shortcuts—they want their shortcuts.

Imagine:

• Vim users remapping to pure hjkl navigation
• Emacs users adding Ctrl-based shortcuts
• Teams standardizing on the same bindings across tools

We built the foundation. Now we're letting you make it yours.

Built for Power Users, From the Ground Up

Hotkeys are just one piece. Here's what else we built for people who care about speed:

The mouse is slow. The keyboard is fast. Power users know this instinctively.

We built an interface that respects your hands. Try the demo above. Press J. Feel the difference.

Once you go keyboard-first, you don't go back.