Building a Fully Keyboard-Driven Development Environment

Introduction

I spend my entire workday without touching a mouse. I navigate my OS, my editor, my browser, my email, my terminal, and my file manager entirely from the keyboard. It's not a flex — it's a productivity choice.

Every time you reach for the mouse, you lose ~0.5 seconds moving your hand off home row, targeting a UI element, clicking, and moving back. Do that fifty times a day and you've lost almost an hour per week. Do that across your entire career and you've lost months.

This guide walks through the exact setup I use on Arch Linux with Sway/Hyprland. The same principles apply on any Linux setup — or macOS if you adapt the tools.

"The fastest way to do something is to never take your hands off the keyboard. The second fastest is to have a keybind for it."

The Philosophy

Before we get into tools, here's the mental model:

1. Every action has a keybind. If you find yourself doing something twice with the mouse, bind it.
2. The terminal is your primary UI. GUIs are secondary. If a tool doesn't have a terminal interface, find a replacement.
3. Modal navigation is faster than pointing. Hitting j three times to move three items is faster than moving the mouse to the third item and clicking.
4. Consistency matters more than choice. Having one set of keybindings across all tools is better than having the perfect keybind in each tool.

Step 1: The Window Manager

A tiling window manager is the foundation of a keyboard-driven setup. I use Sway (Wayland) and Hyprland.

Why a Tiling WM

• Workspaces with keybinds (Super-1 through Super-9)
• Window management without dragging (Super-h/j/k/l for direction)
• No title bars, no decorations — more screen space
• Everything is configured in a text file

My Sway Config

# ~/.config/sway/config

# Workspace switching
bindsym $mod+1 workspace 1
bindsym $mod+2 workspace 2
bindsym $mod+3 workspace 3
# ...through 9

# Move window to workspace
bindsym $mod+Shift+1 move workspace 1
bindsym $mod+Shift+2 move workspace 2

# Vim-style movement between windows
bindsym $mod+h focus left
bindsym $mod+j focus down
bindsym $mod+k focus up
bindsym $mod+l focus right

# Move windows
bindsym $mod+Shift+h move left
bindsym $mod+Shift+j move down
bindsym $mod+Shift+k move up
bindsym $mod+Shift+l move right

# Launcher
bindsym $mod+d exec wofi

# Terminal
bindsym $mod+Return exec kitty

The key insight: Super-h/j/k/l mirrors vim navigation. Your brain already knows these bindings from the editor, so window management becomes instinctive.

Step 2: The Terminal

I use kitty (GPU-accelerated terminal) with these settings:

kitty.conf Essentials

# ~/.config/kitty/kitty.conf

# Vim-style navigation in terminal
map ctrl+shift+h neighboring_window left
map ctrl+shift+j neighboring_window down
map ctrl+shift+k neighboring_window up
map ctrl+shift+l neighboring_window right

# Smart tab completion
shell_integration enabled

# Font configuration for readability
font_family      JetBrains Mono
font_size        12.0
adjust_line_height 2

Tmux for Session Management

kitty handles the terminal emulator, but tmux handles sessions, panes, and persistence:

# ~/.tmux.conf

# Vim-style pane navigation
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Resize panes with vim keys
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# Vim-style copy mode
set -g mode-keys vi

# Faster prefix
set -g prefix C-a

Step 3: The Launcher

WoFi or rofi replaces the application menu and does more:

wofi Config

# Mouse is disabled by default in wofi
# ~/.config/wofi/config

show=drun
width=800
height=600
term=kitty
allow_markup=true

Bind it to Super-d (as shown in the sway config above) and you never scroll through a menu again. Type three letters, press enter, the app opens.

• Applications (Super-d, type name, enter)
• Window switching (Super-tab or custom script)
• Clipboard history (wl-clipboard + wofi)
• Emoji picker (wofi-emoji or similar)
• Calculator (qalc + wofi)

Step 4: Browser Navigation

I covered this in detail in the vim motions post, but here's the condensed version:

• Tridactyl (Zen/Firefox) or Vimium (Chrome): Full keyboard browsing
• f for link hints (type letters, click any link)
• H and L for history navigation
• J and K for tab switching
• d to close tab, u to reopen
• yy to copy URL

• Bookmarks: :b command in Tridactyl, fuzzy search
• Tab search: :tab for fuzzy tab switching
• Downloads: :downloads to see and open recent files

Step 5: Terminal Email

Email is the last frontier of mouse dependency for most developers. I use neomutt with isync for syncing:

neomutt Config

# ~/.config/neomutt/neomuttrc

# Vim-style navigation
bind index j next-entry
bind index k previous-entry
bind pager j next-line
bind pager k previous-line

# Quick search
bind index / search
bind index \ search-reverse

# Send with vim
set editor = "nvim"

It takes a weekend to set up, but once it's running, email becomes a terminal app. Same keybindings as everything else.

Step 6: The Launcher as Universal Interface

Your launcher (wofirofifuzzel) becomes the universal command palette:

Custom Scripts

#!/bin/bash
# ~/.local/bin/launcher.sh

# Clipboard history
cliphist list | wofi --dmenu | cliphist decode | wl-copy

# Window switcher
swaymsg -t get_tree | jq -r '.. | select(.type?) | select(.focused!=true) | "\(.app_id) - \(.name)"' | wofi --dmenu | ...

• WiFi selection: nmcli output piped to wofi
• Bluetooth devices: bluetoothctl devices shown in wofi
• Screen recording: Simple script triggered from wofi
• Password lookup: pass + wofi

What About macOS or Windows?

Most of these tools have equivalents:

• macOS: yabai (tiling WM), kitty/iTerm2, vim extensions in browser, neomutt
• Windows: PowerToys FancyZones, WSL terminal, vim bindings in browser
• The principles hold: Tiling window management, vim everywhere, launcher for everything, terminal-first

Building It Gradually

Don't try to switch everything at once. Here's the phased approach:

Phase 1: Launcher + Browser

Just add a launcher (wofi or Alfred on macOS) and vim bindings in your browser. This alone eliminates most mouse use.

Phase 2: Tiling Window Manager

Switch to a tiling WM for a weekend. It will feel awful. By Sunday it will feel natural. By next week you'll hate dragging windows.

Phase 3: Terminal Everything

Replace GUI tools with terminal alternatives one by one. File manager first (yazi), then email (neomutt), then music (ncmpcpp), then everything else.

Conclusion

A keyboard-driven environment is a long-term investment. The initial setup takes effort — configuring sway, learning launcher scripts, adapting to neomutt. But the payoff accumulates over years.

Every microsecond you save on navigation adds up. More importantly, the mental overhead of context switching disappears. When everything uses the same keybinding language — j/k for downup, ~hl for left/right, /~ for search — your brain doesn't need to switch modes between tools.

The mouse is slow not because pointing is slow, but because the hand movement breaks your flow. Eliminate it, and you'll be surprised how much more you get done.

Up next: we'll look at the editor itself — why I chose Neovim and exactly how I set it up for maximum productivity.