Operate Claude Code fluently at the keystroke level

Working with a coding agent is hundreds of small interactions a day. You notice a failing test, point the agent at the right file, ask a small question while it works, and reuse a command you typed yesterday. Each of those moments is cheap or expensive depending on how you cross it: describing a failure makes the agent reconstruct facts that were already on your screen, while pasting the failure hands it ground truth in one keystroke.

Claude Code - the terminal coding agent this course teaches - also runs with no keystrokes at all: reviewing pull requests and running regression passes while you sleep. The automation chapter covers that end of the range. This chapter is the opposite zoom: the keys you press yourself. None of what follows is a new capability. Everything here still spends the same context window (the agent’s finite working memory for the conversation) and runs under the same permissions as everything else you do in Claude Code. What changes is the cost of each interaction - the course’s cost principle (what a task consumes in money, time, attention, and rework) applied at the keystroke scale - and you repeat these interactions hundreds of times a day, so the cost compounds in one direction or the other. The chapter is deliberately last: fluency is what is left when the primitives stop being the thing you think about.

Describing versus handing over

Watch a fluent operator and a beginner work the same repo - this course’s running example is a small TypeScript payments service with src/payments/processor.ts, src/payments/rate-limiter.ts, and a test suite, but any repo you know shows the same margins - and they reach for identical primitives. The difference is entirely in how each interaction is crossed:

• The beginner describes a failing test - “the tests are red, something about duplicates”; the fluent one runs it with ! and the real output lands in the conversation.
• The beginner types a path from memory and gets the casing wrong; the fluent one @-mentions src/payments/rate-limiter.ts and it is exact.
• The beginner interrupts a long task to ask “what was that fee constant again?”; the fluent one asks with /btw and the run never notices.
• The beginner retypes the same gnarly command; the fluent one pulls it back with Ctrl+R.

No single gap is large. You cross them all day, and the friction - retyping, context pollution, broken focus - quietly adds up. Closing them is what this chapter does, in whatever repo you have open.

The four moves

• Inline input - run a command in your own shell and land its output in the conversation with !; point the agent at exact files with @.
• Images and multi-line prompts - paste a screenshot straight into the prompt, and write a structured spec as one deliberate turn instead of a chain of accidental ones.
• Staying in flow - ask a side question with /btw that never enters the history, catch up with /recap, and stop retyping through history search.
• Editor ergonomics - vim mode if that is how your hands already think, the handful of shortcuts that earn their keep, and /config plus /keybindings for the rest.

Each move states its own value and works on its own; read them in order if you are new, or jump to the one that bites you today. By the end you will have run out of course, and that is the point: the primitives were the hard part, and this is the polish that makes them disappear into reflex. Start with the inline moves.