Keyboard-First AI Coding Assistant Habits

Keyboard-first AI coding assistant habits are how working developers keep Copilot, Cursor, and Claude Code from becoming a second job in the mouse. If every question requires opening a chat panel, selecting a model, pasting a file, and writing an essay, you will stop asking. Then you will paste too much, once, when you are tired. This post is the bindings, the snippets, and the refusal rules. Tool routing lives in Cursor vs Claude Code vs Copilot; this is the hands.

Key Takeaways:

• Bind three verbs only: complete, ask-on-selection, agent-in-repo — everything else is a smell.
• Keep prompt snippets in the editor, not in a bookmark folder of screenshots.
• Never bind “send whole project” or “accept all”; glance is part of the keystroke.
• Secrets do not get a shortcut — scan locally, chat on a selection.
• Measure habits by reverted diffs and skipped mouse trips, not by tokens.
• Teach the bindings as a short curriculum so juniors do not invent a GUI ritual.

Table of Contents:

• Why the mouse makes AI worse
• The three verbs worth binding
• Snippets instead of prompt essays
• Accept, reject, and the glance
• Terminal, git, and tests without leaving home row
• What not to automate
• Week-one keymap across editors
• Frequently Asked Questions

Why the mouse makes AI worse

A mouse-driven assistant session looks like this: highlight nothing, click Chat, attach src/, type “make it better,” scroll, click Apply, click Undo. That sequence is slow and leaky. You attached src/ because the GUI made it easy. AI pair programming without leaking secrets is easier when the default is selection, which a keybinding enforces.

Keyboard-first is not aesthetics. It is a smaller default context window. Smaller context is better security and better answers. It also matches how we already use git and the debugger.

Cursor documents keyboard-centric chat and inline edit (Cursor docs). VS Code / Copilot the same for completions (GitHub Copilot). Claude Code is already keyboard-native — it is a CLI (Claude Code). Your job is to stop using the CLI like a GUI app you paste novels into.

This sits inside a backend engineer daily workflow and inside reading a new codebase: jump to definition, then ask.

If you need a self-hosted CLI instead of Claude Code, that is OpenClaw vs Claude Code — still keyboard-first.

The three verbs worth binding

Pick keys you can hit with muscle memory. Exact chords depend on Cursor vs VS Code vs JetBrains. The verbs do not.

1. Complete (Tab / ghost text)

Copilot or Cursor Tab. No prompt. The prompt is the comment or the test name you typed. See prompt AI for better unit tests.

Do not bind “cycle 12 completions.” One Tab, Esc is enough. If the completion is wrong twice, write it.

2. Ask on selection

Chat with the current selection as implicit context. Your snippet library starts with:

Quote this symbol's callers. Paths only.

What invariant do the tests near this function lock? Quote assertions.

Do not edit. List failure modes if this returns 500.

This is how you read a new codebase without @codebase on day one.

3. Agent in repo

A terminal split you already live in:

alias ccq='claude'
# You type:
ccq "Run tests for this package only. Do not edit. Paste the failures."

Keep a histfile of good agent one-liners, not of prompts that contained dumps.

MCP is not a verb. Do not bind “open MCP inspector” into the daily three. When you need protocols, read MCP explained with real code. Production agents are a product; this post is editor hygiene.

Snippets instead of prompt essays

Store these as editor snippets (ask-callers, ask-diff-bound, ask-tests, ask-rfc). Expanding a snippet is keyboard-first; rewriting philosophy is not.

Bound edit:

Edit only:
- $TM_FILENAME
Do not add dependencies.
Do not rename public symbols.
Invariant: $CLIPBOARD

You copy the invariant from the ticket you sanitized. Tickets are untrusted (prompt injection).

Review hunt (from AI code review):

Hunt this diff for: authz miss, missing test, secret-shaped strings.
No style. No praise.

RFC expand (from AI for RFC design docs):

Fill Current behavior with quotes. Do not touch Decision.

Commit draft (from AI commit messages):

git cm   # alias that pipes git diff --cached

You still open the editor for the subject line. --no-edit is not keyboard-first; it is skip-brain.

SQL

Do not bind “explain selected SQL” to send prod results. Bind it to send the statement plus EXPLAIN output you already ran locally. ChatGPT for SQL you forgot.

Accept, reject, and the glance

Keyboard-first fails if Accept All is one key.

Rules:

• Tab accepts ghost text for the current line / block you can see.
• A dedicated key accepts an inline edit hunk.
• No key accepts a 14-file composer patch. That path requires a diff glance, which may be a mouse. Live with it.

If you revert more than you accept, your bindings are too eager. Log it:

echo "2026-09-21 | reverted composer 8 files | bind was too wide" >> ~/.ai-habits

Same honesty as backend daily workflow: measure reverted work.

Glance checklist (two seconds):

• Files you did not name
• .env or *.pem
• package.json / go.mod you did not intend
• Tests deleted

Ocherfort is not a keybinding, but it is a preflight you can alias:

alias preai='ocherfort scan'

Local-first repo security CLI. Run preai before the first agent session of the day, especially on an unfamiliar branch. HinterBuild treats that as cheaper than an incident write-up.

Terminal, git, and tests without leaving home row

You already have this if you are a backend engineer. Do not replace git with a chat.

# tests nearest (example)
alias t='pytest -q'
alias tg='go test ./... -count=1'

# diff then think
git diff --stat

Claude Code should call these, not replace them. You should be able to run tests when the vendor is down. That is why AI agent development is a different product from “my editor.”

Onboarding a junior? Do not start with 40 Cursor GUI tips. Start with jump-to-definition, then one ask-on-selection binding, then preai. Package that as a series with Cadensend: open-source email curriculum engine, sources from your keymap doc and CONTRIBUTING.md (GitHub). Personal coding curricula belong there too — “my Cursor chords this month.”

Cadensend will not bind your keys. It will stop the keymap from living in one person’s head.

What not to automate

• Merge. No keystroke merges because a bot was green.
• Push --force. Obviously.
• Apply patch from untrusted HTML. Injection (prompt injection guide).
• Send whole repo to a new model to “see if it’s smarter.”
• Auto-commit. Commit messages stay edited.
• Auto-RFC. RFC docs need a human decision sentence.

MCP auto-invoke on a key is how you get a calendar tool in a pairing session. Default off.

If HinterBuild wires agents into your SDLC, we do it as backend API engineering plus AI agent development, with explicit tools — not as a hotkey that can dump env. Contact if that is the install you want. About for how the company works.

Week-one keymap across editors

Do not copy someone else’s keybindings.json on day one. Bind the three verbs to keys you already use for “command palette” adjacent chords, then stop.

Cursor / VS Code (illustrative — check the current command names in the palette):

• Inline complete: keep Tab
• Ask on selection: Cursor: Open Chat or GitHub Copilot: Ask with selection
• Inline edit: the “edit this” command, not Composer-all
• Terminal: Ctrl-`, then ccq alias

JetBrains: map “AI Chat” to a chord that already feels like Find in Files. Do not give the AI the same chord as Reformat Code. You will reformat a secret into a prompt by reflex.

Neovim: if you already live in visual mode, the selection is the prompt. A plugin that sends the whole buffer on <leader>a is how dumps travel. Bind visual-only.

Write the map in the repo:

# .ai-keymap.md (human-owned)
complete: Tab
ask-selection: <your chord>
inline-edit: <your chord>
agent: terminal ccq
preflight: preai  → ocherfort scan
run-nearest-test: <already bound>

That file is a teaching source. Feed it to Cadensend with CONTRIBUTING.md. Juniors should not learn AI as a click tour of the latest Cursor layout. Layouts change. Verbs do not.

A 20-minute drill

1. Open a handler. Jump to definition (no AI).
2. Select the function. Ask callers. Glance.
3. Name a test. Tab-complete the body. Run nearest test (unit tests).
4. git diff. Alias for commit draft. Edit subject (commit messages).
5. preai. If it yells, you do not chat (secrets pairing).

Time it. If step 2 took a mouse and three model-picker clicks, the binding failed.

Conflicts with existing muscle memory

If Tab is indent in a markdown RFC, disable completions in markdown. RFCs are decision documents, not a place for ghost-text adjectives. If Copilot fights Cursor Tab, pick one complete verb — the daily routing post is about surfaces, this post is about not having two Tabs.

tmux users: keep Claude Code in a dedicated pane, not a popup. Popup UIs train the mouse. Reading a new codebase is rg in the pane you already have, then one ask.

SQL: never bind a chord that sends the query results. Bind one that sends the statement. ChatGPT for SQL.

Review: a chord that pastes the whole PR into chat is a leak chord. Bound diff only — AI code review.

If the “assistant” is OpenClaw or another self-hosted CLI, the verbs stay. The binary changes. See OpenClaw vs Claude Code. Do not grow a web UI around a CLI just to click Apply.

Frequently Asked Questions

Should I disable the mouse in Cursor?

No. Use it for the rare 14-file diff. Bind the common path so you are not forced through the GUI attach-everything flow.

What if my teammates use the GUI?

Share the three verbs and the snippet file. Do not fight fonts. A Cadensend series plus a pairing hour beats a tooling war.

Is Tab completion keyboard-first enough?

It is one of three verbs. If Tab is all you use, you will never ask the repo a question and you will never hunt. Read the daily Cursor / Claude Code / Copilot split.

How do I keep secrets out if snippets expand fast?

Snippets should not include @.env. Alias preai to Ocherfort. Selection-default chat. Full pairing rules: without leaking secrets.

Can I bind “fix failing test”?

Yes, if the command runs the failing test and the prompt forbids extra files. Still glance the diff. Test quality: better unit tests.

Does this replace learning the editor?

No. Keyboard-first AI assumes you can already move. If you cannot jump to definition, learn that first (read a new codebase).

Where does OpenClaw fit?

Same verbs, different binary. Do not grow a GUI ritual around a CLI. Comparison: OpenClaw vs Claude Code.

Conclusion

• Bind complete, ask-on-selection, and agent-in-repo; store prompts as snippets.
• Default small context; glance multi-file diffs; never hotkey merge or force-push.
• Scan locally, treat tickets as data, and teach the chords as a curriculum.
• For a team keymap plus scanner plus series, contact HinterBuild or start from about.