Tune editing ergonomics with vim mode, key shortcuts, and /config

One layer of daily friction is left: the prompt input itself, and the keys you press a thousand times a day to drive it. None of this changes what Claude Code can do. It changes how little friction sits between a thought and a submitted prompt - and a small saving on every edit compounds across a day of steering the agent.

Vim mode, when your hands already speak it

If you edit everything else in vim, a plain readline buffer is a small constant tax: your fingers reach for Esc, dd, ciw, and nothing happens. Claude Code has a full vim editing mode for the prompt, enabled under /config - Editor mode, per the interactive-mode docs. The input gains NORMAL and INSERT modes with the motions and operators you expect: h/j/k/l, word motions, dw/cw/dd, text objects like ci", and visual mode.

Two interactions keep the mode from surprising you. When the cursor sits at the beginning or end of the input and cannot move further, j/k and the arrows switch to navigating command history - vim motion and history browsing share keys, as you would want. And / in NORMAL mode opens reverse history search, the same one as Ctrl+R. If vim is not your default, skip this entirely: forcing modal editing onto hands that do not speak it is friction, not relief.

The keys worth committing to muscle memory

The keyboard reference is long, and most of it you will never touch. A small set comes up constantly:

Esc            interrupt Claude mid-turn; completed work is kept
Esc Esc        empty prompt: open the rewind menu; with text: clear the draft
               (saved to history, recallable with Up)
Ctrl+R         reverse history search
Ctrl+G         open the current prompt in your $EDITOR
Ctrl+O         toggle the transcript viewer
Ctrl+L         redraw or clear the screen; input and history are kept
Ctrl+B         background a running Bash command or agent; tmux users press
               twice (the tmux prefix key eats the first press)
Ctrl+X Ctrl+K  stop all running background subagents in this session and turn
               off artifact auto-replies for the rest of it; press twice
               within 3 seconds to confirm
Shift+Tab      cycle permission modes

Several of these connect to moves covered elsewhere in the course. Esc is the gentle interrupt: it stops the current response or tool call, and everything already done stays done - a course correction, not a Ctrl+C to the session. Double-Esc on an empty prompt opens the rewind menu (checkpoint restore, from the sessions chapter); with text in the buffer it clears the draft to history instead. Shift+Tab cycles the permission modes - the named postures deciding when Claude Code asks before acting (the permissions chapter covers them). Ctrl+R is the history search the flow lesson puts through its paces.

Ctrl+B and its cleanup chord Ctrl+X Ctrl+K bracket a backgrounding habit: send a long command or agent to the background with Ctrl+B and keep working, then stop every background subagent (subagents typically run there already - fork mode is on by default) at once with Ctrl+X Ctrl+K when the session’s real work is done. The confirm-press on the chord is deliberate - it also turns off artifact auto-replies (the follow-up messages backgrounded agents post when they finish) for the rest of the session, which you do not want to trigger by accident. Both the double-press confirm window and the tmux double-press are documented in the interactive-mode reference.

Ctrl+G and Ctrl+O deserve their own call-out. When a prompt grows past a couple of lines - the four-constraint spec shape from the spec lesson - Ctrl+G pops it into your real editor; a /config option can prepend Claude’s previous reply as #-commented context, stripped on save (the “Show last response in external editor” toggle, per the interactive-mode reference).

Ctrl+O toggles the transcript viewer: full tool calls, timestamps, model info, collapsed MCP lines expanded. It is the difference between reading a summary of what a tool call did and reading the call.

/config once, /keybindings when a key is wrong

Most of the friction that is left lives in /config. It opens the settings interface - theme, model, output style, the session-recap toggle, the external-editor behavior that pairs with Ctrl+G - and it also sets values directly, as in /config theme=dark. It is worth opening once, deliberately, and reading down the list rather than discovering each toggle the hard way; five minutes here removes annoyances for months.

And if a default key itself is wrong for you - it collides with your terminal multiplexer, or you want Ctrl+R somewhere else - the keys are not fixed. /keybindings creates or opens ~/.claude/keybindings.json, where you rebind actions per context, or unbind a default outright by assigning it null. Edits are detected and applied without restarting; the full action list and keystroke syntax are in the keybindings reference.

A few keys stay reserved: Ctrl+C and Ctrl+D are hardcoded interrupt and exit, Ctrl+M, Ctrl+[, and Ctrl+I always arrive as Enter, Escape, and Tab, and Caps Lock never reaches a terminal application at all.

The course ends on the habit

That is the whole course. Look back at the arc on the payments repo - the small TypeScript service this course uses as its running example - stated as what each chapter actually left you with. You installed Claude Code and made one bounded change you could defend, keeping the verify loop your own. You learned to keep decisions alive across sessions and to read context as a resource. You set the permission dial deliberately, long where it is safe and short where it is not.

You made the agent design before it built - and the idempotency fix it designed is still a plan on disk, its implementation deliberately yours to finish. You audited the repo’s rules and saw that memory informs but never enforces. You matched model and effort to the task, found the balance bug by delegating the trace, and packaged the wrap-up ritual as a skill.

You gave the agent reach, gates, and shipping with MCP, hooks, and plugins, then automated review itself - pull requests and the night shift, fail-closed. This chapter smoothed the moves between all of that into reflex.

None of those chapters was about a command. They were about one habit, applied a dozen ways: context is spent on purpose, permissions are set on purpose, plans are steered on purpose. Fluency is that habit running without your attention - which is also why it survives the next tool you pick up.

Three places to go from here. Nearest: the course’s quick reference - the commands, shortcuts, flags, and modes these lessons used most, one lookup away. When you want the spec-level reference - the exhaustive “what is this primitive and every option it takes” view this course deliberately kept light - that is Foundations, the lookup-shaped other half of the same picture. And if you work across more than one agent, the Codex course and the OpenCode course are live here on the same teach-by-doing spine you just followed.

The payments repo still has its planned-but-unlanded fix, its float math waiting for the cents rule, its corners unaudited. That is what a working repo looks like: never finished, always steerable. Open a session, check what it sees, decide what it may do, and steer the plan on purpose. The rest is reflex now.