Daily workflow

The last chapter was about handing whole jobs to Claude Code unattended — headless runs, CI, loops that work while you sleep. This one zooms all the way back in, to the keystrokes. Because the truth a week of payments work has been quietly teaching you is that most of your time isn’t spent on the big primitives at all. It’s spent in the small gaps between them: pasting in a stack trace, pointing at a file, asking a quick side-question, fishing a command back out of history. None of those are new capabilities — they’re the friction you remove once the rest is second nature.

That’s what this chapter is, and it’s deliberately the course’s last: not another primitive, but the fluency that ties them together. Everything you’ve learned still spends the same context window, still runs under the same permissions, still slots into the same plans. The moves here just make using all of it feel like an extension of your own hands instead of a thing you operate.

What “fluent” actually looks like

You’ve shipped the week’s payments work. Idempotency is in, the rate limiter holds, the tests are green. If you watched a fluent operator do that same week and a beginner do it, they’d reach for the identical primitives — plan mode, allow rules, /compact. The difference is entirely in the margins:

• The beginner describes a failing test to the agent; the fluent one drops its output in with ! and lets the agent read the real thing.
• The beginner types out a path and gets it slightly wrong; the fluent one @-mentions the file and it’s exact.
• The beginner interrupts a long task to ask “what was that config file called again?”; the fluent one asks with /btw and never derails the run.
• The beginner retypes the same gnarly command; the fluent one pulls it back with Ctrl+R.

None of those gaps is large. But you cross them hundreds of times a day, and the cost — in friction, in lost focus, in context pollution — compounds. Closing them is what this chapter does.

The moves we’ll pick up

A short tour, in the order they tend to matter:

• Inline input — feed the agent a real command’s output with !, point at exact files and folders with @, paste a screenshot straight in, and write a multi-line prompt without fighting the Enter key.
• Staying in flow — ask a side-question with /btw without polluting the thread, catch up on a session with /recap, and stop retyping commands by searching your history.
• Editor ergonomics — turn on vim mode if it’s how your hands already think, memorise the handful of shortcuts that earn their keep, and tune the rest in /config.

By the end you’ll have run out of course — and that’s the point. The primitives were the hard part; this is the polish that makes them disappear into reflex. Start with the inline moves.