TECHThe Smallest Agent That Works, Part 3: The Three Agents With StateTECHThe Smallest Agent That Works, Part 2: The Three Reach-Out AgentsTECHThe Smallest Agent That Works, Part 1: The Three Cheap AgentsTECHWhat MLX Got to Throw Away (That PyTorch Can't)TECHThe Unified-Memory Bet: Why On-Device Inference Stopped Being a ToyTECHEvery Useful Skill Is One of Five ShapesTECHMCP Gives You the Kitchen. Skills Are the Recipe.TECHThe Three-Level Skill, and Why Yours Is Probably One Level Too ManyTECHThe Smallest Agent That Works, Part 3: The Three Agents With StateTECHThe Smallest Agent That Works, Part 2: The Three Reach-Out AgentsTECHThe Smallest Agent That Works, Part 1: The Three Cheap AgentsTECHWhat MLX Got to Throw Away (That PyTorch Can't)TECHThe Unified-Memory Bet: Why On-Device Inference Stopped Being a ToyTECHEvery Useful Skill Is One of Five ShapesTECHMCP Gives You the Kitchen. Skills Are the Recipe.TECHThe Three-Level Skill, and Why Yours Is Probably One Level Too Many
AI × Forward
Subscribe
Tech

The Claude Code Shortcuts That Actually Earn Their Keystroke

Most Claude Code shortcut listicles rank commands alphabetically and call it a day. Half of them never earn the keystroke. Eight commands and four keyboard moves cover most sessions — the honest part of the list is which twenty you can skip.

Initial Editor·2026-04-29·6min read·1,214 words

Most Claude Code shortcut lists rank commands alphabetically. That's how you end up reading about /color before you've heard of Esc Esc. The bar that matters isn't "does it exist." It's "does it earn the keystroke." On most days, eight commands and four keyboard moves cover everything. The other twenty don't.

Below: a four-tier ranking of every command worth knowing about, plus the keyboard shortcuts most listicles forget exist. Daily-drivers, the on-purpose layer, one-time setup, and the ones that don't deserve a click.

1. The eight you'll hit every session

Naming a shortcut "Tier 1" is cheap. The honest test: did you reach for it in the last 24 hours? These earn it.

Shortcut What it does Why it's daily
Esc Interrupt the current generation The single most-pressed key. Cheaper than waiting for a wrong direction to finish.
Esc Esc Edit a previous message and re-fork from that point Beats "let me clarify" rounds — you go back, change the prompt, branch fresh.
Shift+Tab Toggle plan mode / auto-accept Plan mode for "think before touching files." Auto-accept for "I trust this loop."
@ (in input) Reference a file by path Faster than pasting paths, and the agent gets the actual file, not a paraphrase.
# (start of input) Save the line to CLAUDE.md Memory edits without leaving the prompt.
! (start of input) Run the rest as a shell command in this session Login flows, env checks, anything interactive without dropping out of the conversation.
/clear Wipe context and start the session over When the conversation has drifted and /compact won't save it.
/compact [instructions] Summarize old turns; keep what you tell it to keep The middle ground between /clear and "let it auto-compact whenever."

Notice the split: half keyboard, half slash. Lists that only count slash commands miss the actual leverage.

2. The dozen you reach for on purpose

These don't fire every hour, but when you need one, the substitutes are awful.

Shortcut When it pays for itself
/model Switching mid-session — Opus for architecture, Haiku for mechanical edits.
/cost Mid-session sanity check. Pairs with /model when a task has slid into the wrong tier.
/context "Why is the agent forgetting things?" — usually a pruned context window, and this tells you.
/resume Continuing a session you closed; the only sane way back into a long-running task.
/rewind Revert files plus conversation to an earlier turn. The "undo my last 20 minutes" button.
/agents Configure subagents — the parallel-execution layer most users never enable.
/add-dir Multi-repo work: pull a sibling repo into the session without restarting.
/mcp Manage external MCP server connections (Notion, Linear, GitHub, Postgres).
/permissions Tighten or loosen tool access; useful when you've been auto-confirming "yes" for an hour.
/hooks Wire automated behavior into events (pre-commit, post-tool-call). Anything "from now on, every time" lives here.
/skills List installed skills — the discovery surface for what the project actually supports.
/security-review Run the security pass on pending changes before opening the PR.
/vim Vim editing in the input box. One-time toggle; the keystroke savings compound.

3. The ones you touch once and forget

Set-and-forget territory. Run them on day one of a project; never again.

  • /init — generate the first CLAUDE.md. Once per project.
  • /memory — open the same CLAUDE.md in your editor. Once per major shift.
  • /config — model defaults, theme, environment switches. Once per machine.
  • /ide — link to VS Code or JetBrains. Once.
  • /login, /logout, /doctor, /release-notes — account and tooling housekeeping. Run when something breaks; not part of the loop.

If you're typing /init more than once a week, something else is wrong.

4. The ones that don't earn the keystroke

The honest cut. These exist; that doesn't mean you should use them.

Command Why to skip
/diff Your editor and git diff already do this, with syntax highlighting and word-wrap.
/export git log -p produces a more useful transcript than a flat dump of conversation.
/theme Buried in /config already; one less surface to remember.
/rename Sessions aren't chat threads. Naming them is overhead with no payoff at the CLI.
Any command you can't recall the syntax of by Wednesday If you have to look it up every time, the time saved is negative.

The principle: a shortcut that needs a man-page lookup costs more than the click it replaces.

5. The shortcuts the listicles miss

Three keystrokes that don't appear on most "26 shortcuts" charts and earn their place anyway:

  • Ctrl+R — toggle verbose mode. When the agent's behavior surprises you, this exposes the tool calls so you can see why. Pair with debugging.
  • Backslash + Enter (or Option+Enter) — multi-line input. The difference between writing a real prompt and a one-line gesture.
  • Up arrow, then Esc Esc — the actual "edit a previous message" workflow. Up arrow recalls the prompt; Esc Esc rewinds the conversation to that point so the edit re-forks cleanly.

Then there's the CLAUDE.md and AGENTS.md files themselves. Not shortcuts in the strict sense, but the highest-leverage "shortcut" available — they replace re-explaining your stack at the top of every session. The # prefix from Tier 1 is the maintenance interface for them.

Where this maps to the actual workflow

The tier list collapses into a smaller daily checklist:

Moment Reach for
Agent went the wrong direction Esc, then Esc Esc to rewrite the prompt that started it.
Context window feels full /compact <what to keep>, fall back to /clear.
Bill creeping up /cost, then /model haiku for the mechanical work.
Need to think before files change Shift+Tab into plan mode.
Picking back up tomorrow /resume, not "open a new session."
About to merge /security-review first, then a code review pass on the diff.

Six moves cover most days.

When this ranking goes wrong

This is opinionated, not universal. The rankings shift if:

  • You're auditing prompts more than building. /export and /diff move up; the conversation itself is the artifact.
  • You run a single project for months. The one-time-setup tier collapses to never; the daily list shrinks further.
  • You work across many sandboxes a day. /add-dir, /mcp, and /permissions move to Tier 1 because the ceremony resets every session.
  • You're on a regulated or locked-down machine. /permissions and /hooks are daily, not monthly, because the policy edits are constant.

Most "26 shortcuts" lists are scaffolding. The actual leverage sits in eight commands and four keystrokes. Knowing which twenty don't earn the click is more useful than memorizing the full set.

// more in tech

see all →
Tech· 2026-05-29· 5min

The Smallest Agent That Works, Part 3: The Three Agents With State

Stateless agents fit most tasks. State is the most expensive capability you can add — it doubles your operational surface, breaks your debugging, and rewards exactly the use cases that can't survive without it. Memory, environment control, self-learning. Part 3 of three.

#agent-architecture#ai-engineering#ai-agents#system-design
Tech· 2026-05-27· 5min

The Smallest Agent That Works, Part 2: The Three Reach-Out Agents

When the cheap tiers run out, the agent has to reach beyond the model itself — into knowledge it doesn't have, tools it can't natively use, or its own previous answer. RAG, tool use, and self-critique: three patterns, three failure modes worth pricing in. Part 2 of three.

#llm#rag#agent-architecture#ai-engineering
Tech· 2026-05-26· 5min

The Smallest Agent That Works, Part 1: The Three Cheap Agents

Most agent stacks are built one tier too capable for the job. Three of the cheapest architectures — a fixed pipeline, an LLM with rule constraints, and a reasoning loop — solve more problems than the architecture diagrams admit. Part 1 of three.

#llm#agent-architecture#ai-engineering#ai-agents
Tech· 2026-05-15· 5min

What MLX Got to Throw Away (That PyTorch Can't)

Every mature framework is a museum of decisions you can't take back. MLX is interesting mostly because it started after the decisions that matter for Apple Silicon were already mistakes — and the things it threw away are the things that were quietly costing the rest of us the most.

#ai-engineering#apple-silicon#mlx#ml-frameworks
Tech· 2026-05-15· 5min

The Unified-Memory Bet: Why On-Device Inference Stopped Being a Toy

For two years the industry's default answer to every inference question has been "bigger cluster." A different hardware topology is quietly making that the wrong default for a non-trivial slice of workloads — and the framework layer that earns it is the buzzword most decks haven't caught up with yet.

#hardware#ai-infrastructure#inference#edge-ai
Tech· 2026-05-14· 5min

Every Useful Skill Is One of Five Shapes

Skills aren't a freeform format. The useful ones fit one of five shapes — sequential workflow, multi-MCP coordination, iterative refinement, context-aware selection, domain-specific intelligence. Picking the right shape is most of the design work. Picking the wrong one is most of the bugs.

#claude-code#workflow#agents#skills