Feed the agent input inline with !, @, and pasted images

Watch yourself work for an hour and you’ll notice how much of the friction is in getting things in front of the agent. You describe a failing test instead of showing it. You type a path from memory and fumble the casing. You try to explain what a broken layout looks like in words. Every one of those is a place where you could be handing Claude Code the exact thing instead of an approximation — and the inline input moves are how you do it without breaking stride.

! — your shell, not the agent’s

You already met the ! prefix back in permissions, where it earned its place as the move that needs no permission prompt: a line that starts with ! runs in your shell, immediately, and drops its output into the conversation. That’s you running the command, not the agent asking to — so there’s nothing to approve.

What that lesson left for here is how much leverage it gives you day to day. The payments tests are flaking; rather than ask the agent to run them and wait, you look yourself and hand it the result:

> !npm test 2>&1 | tail -20

  ⎿ FAIL test/idempotency.test.js — expected one charge, got two
    (output added to context)

> a retried request is still double-charging. the dedupe check is racing. fix it.

Two small things the interactive-mode docs add that are worth banking. First, ! commands have their own history-based autocomplete — type a partial command and press Tab to complete it from previous ! commands in this project, so the gnarly npm test … | tail only gets typed once. Second, you can paste a chunk of text that starts with ! into an empty prompt and it drops into shell mode automatically, the same as if you’d typed the !. To leave shell mode without running anything, press Escape or Backspace on the empty ! prompt.

The instinct to build: when you find yourself narrating a fact to the agent — “the test fails with a 500”, “git status is dirty” — stop and ! it instead. A described fact is lossy; a pasted one is ground truth.

@ — point at exact files and folders

The companion to ! is @. Type @ anywhere in your prompt and Claude Code opens file-path autocomplete, per the same docs — start typing a name and it completes against your project tree, so you reference the real path instead of one you half-remember:

> the race is in @src/payments/charge.ts — compare it to how @src/payments/refund.ts
  guards against duplicates and apply the same pattern

  ⎿ Read charge.ts, refund.ts

Two reasons this beats typing a path inline. It’s exact — no guessing whether the file is charge.ts or charges.ts, no wrong directory. And it’s a deliberate signal: @-mentioning a file tells the agent this is in scope, read it without you having to write “go look at” around it. You can mention a directory the same way to point it at a whole area. It pairs naturally with !: ! shows the agent the dynamic state of the world, @ anchors it to the static files that state came from.

Pasting images straight in

Some problems don’t live in text at all — a misrendered receipt page, a chart that’s wrong, a screenshot of a stack trace from a teammate’s terminal. You don’t have to save those to disk and describe the path. Copy the image to your clipboard and paste it directly into the prompt: on most setups that’s Ctrl+V (note: not the terminal’s usual Cmd+V paste, which won’t carry the image — though iTerm2 maps Cmd+V, and Windows/WSL use Alt+V). Claude Code inserts an [Image #N] chip at the cursor so you can refer to it in place:

> the payments dashboard renders this for refunded orders [Image #1] —
  the badge should say "Refunded", not "Paid". it's in @src/components/StatusBadge.tsx

The exact paste binding is one of the more platform-dependent shortcuts, so if it doesn’t take, the interactive-mode reference lists the per-terminal keys. But the habit is the point: a screenshot carries detail your words would flatten, and the agent reads it.

Writing more than one line

The last bit of inline friction is the Enter key. By default Enter submits, which is exactly wrong when you want to write a prompt with structure — a few bullet points, a short spec, a snippet pasted between sentences. You don’t want each line firing off as its own turn.

The portable way to add a newline without submitting is \ then Enter — a backslash at the end of the line, which works in every terminal. There’s also Ctrl+J, which inserts a newline with no configuration at all, and in many modern terminals Shift+Option+Enter or a plain Shift+Enter works once set up. If Shift+Enter doesn’t, running /terminal-setup installs the binding for the common editors. The full per-terminal matrix is in the interactive-mode docs; pick whichever one your fingers will remember.

> here's what the idempotency middleware needs to do: \
  - read the Idempotency-Key header \
  - if we've seen it and the charge finished, return the stored result \
  - if we've seen it but it's still in flight, return 409 \
  - if it's new, proceed and record the key \
  write it as express middleware in @src/payments/middleware/

That’s a real spec the agent can build against, written as one prompt instead of five accidental ones.

Together these four moves cover getting things in — output, files, images, structured prompts. The next set is about what happens once you’re in flight: how to ask a question, catch up, or reuse a command without breaking the thread you’re working in. That’s staying in flow.