Keyboard-Driven Development: Why I Built It

How ergonomic needs and developer efficiency led me to build a fully keyboard-driven workflow.

“The tools shape the work.”

When screen time surged during the pandemic, I began to feel the strain — literally.
Hours of typing and constant mouse movement introduced tension and fatigue I hadn’t noticed before.
So I started an experiment that would transform how I code, navigate, and communicate: Keyboard-Driven Development.


The Problem: Fatigue, Friction, and the Mouse

Like many developers, my day had become a blur of meetings, terminal windows, and code reviews.
By late 2020, my wrists and shoulders were telling me something was wrong.

I tried the usual fixes — ergonomic chair, wrist rests, desk height tweaks — but the discomfort persisted.
Eventually, I realized the root cause wasn’t just posture. It was context switching.

Every time I moved between keyboard and mouse, my brain had to change modes.
Each switch cost a few seconds of momentum — multiplied by hundreds per day.
Over time, that friction added up.

I wanted to reclaim that flow — to create an environment where I never had to leave the keyboard.


The Idea: What “Keyboard-Driven” Really Means

“Keyboard-driven” isn’t just about memorizing shortcuts.
It’s about designing an environment where the keyboard is the primary control surface for everything.

It means:

  • No mouse, no trackpad.
  • Minimal context switching.
  • One consistent language for interacting with tools.

Every key and modifier becomes programmable real estate — a decision you can shape to match your habits.

When your environment speaks your muscle memory, you stop using tools and start thinking through them.


The Vision: Ergonomics + Efficiency

What began as a response to wrist fatigue evolved into a deliberate design for flow.

By customizing hardware, layout, and software, I found not just comfort — but speed, clarity, and focus.
My typing became more balanced. My transitions between windows and tasks became instant.
Most importantly, my tools stopped interrupting my thoughts.

Ergonomics removed the pain.
Customization unlocked the performance.
Together, they created sustainable speed.


The Stack

Here’s the core of my Keyboard-Driven Development setup — every layer tuned for comfort and control.

Tool Role Highlights
Kinesis Advantage360 Pro Ergonomic split keyboard Custom ZMK firmware, Colemak Mod-DH layout
Colemak Mod-DH Typing layout Reduced finger stretch, balanced hand load
tmux Terminal multiplexer Session persistence, pane navigation without mouse
neovim Text editing & coding Modal editing, keyboard-first workflow
neomutt Email client Fast terminal-based mail handling
awesomeWM Tiling window manager Full keyboard navigation, window automation
zsh + fzf + ripgrep Shell environment Instant search and navigation

Each tool fits together like modular hardware — ergonomic at every level, from physical keystrokes to digital windows.


The Road Ahead

This post kicks off the Keyboard-Driven Development series, where I’ll break down each component of the setup in detail:

  1. Keyboard-Driven Development: Why I Built It (this post)
    The philosophy and vision behind the keyboard-driven workflow.
  2. Colemak Mod-DH: The Typing Layout That Changed Everything
    Why I switched, and how I adapted it to the Kinesis.
  3. tmux for Keyboard-Driven Development
    Keyboard-driven pane, window, and session management.
  4. Neovim as the Development Core
    Plugins, motions, and mappings integrated with the layout.
  5. Kinesis Advantage360 Pro: My Setup & Workflow
    Custom layers, macros, and firmware with ZMK.
  6. NeoMutt: Terminal-Native Email for the Keyboard-Driven Developer
    Fast, scriptable email client with mbsync, msmtp, and full-text search.
  7. Bringing It All Together: A Day in the Life
    Walking through a full workflow — no mouse required.

Closing Thoughts

Ergonomics was the starting point.
Efficiency became the destination.

Keyboard-Driven Development is about crafting an environment that moves at the pace of your ideas — where comfort, speed, and clarity converge.

If you’ve ever felt the fatigue of modern computing, or the friction of switching between tools, I hope this series helps you rediscover the joy of flow through simplicity.


Keyboard-Driven Development Series

Part 1 of 8