We have been running Claude Code as our default coding assistant at Airfind since the CLI launched. Some of its features we figured out immediately. Others we stumbled on months in and thought, “why did nobody tell us about this?” This is the tips list we would give our past selves, ordered by how much each one changed our day.

Resume sessions, always

Running claude on its own starts a fresh session. That is fine for a one-off task. But most real work is iterative, and losing context between sessions is expensive. Use claude --resume to pick a prior session from a list, or claude --resume <session-id> to jump directly into one. We keep a handful of long-running sessions going at any time: one for the current feature, one for review work, one for infra.

The reason this matters: Claude 4.7 with ongoing context makes smarter decisions on turn 20 than on turn 1. Throwing that context away every time is like firing your senior engineer and hiring a new one every morning.

Custom skills are the leverage feature

Skills are reusable prompts that you invoke with a slash command. Most people treat them as shortcuts for boilerplate. That undersells them. A skill is a chance to codify how your team wants a task done. If there is a specific shape of code review, PR description, or release note you want every time, put it in a skill and forget about writing the prompt again.

Our most-used internal skill is /review-diff: it runs the agent against the current git diff, checks for our house-style violations, and flags missing tests. Before the skill, one of us was writing the same three-paragraph prompt every morning. After the skill, it is one slash command. That compounds.

Subagents for independent work

Claude Code supports spawning subagents with the Agent tool. Subagents run in their own context window and report back when done. This matters more than it sounds. When you have three independent lookups to do (find all usages of a function, check the test coverage, review the open PRs) you can fan them out in parallel. The main conversation stays clean. Your context budget goes further.

The gotcha: subagents cannot see your conversation state. Brief them like you would a smart colleague who just walked into the room. Write the prompt as if they know nothing. Short, complete briefs. Otherwise you will get back shallow work.

Hooks for guardrails

Hooks are shell commands that run in response to events (before a tool call, after a tool call, when the agent stops, etc.). They are the cleanest way to enforce team conventions without stuffing a huge system prompt. A few hooks we run:

  • PreToolUse on Bash: block any git push --force to protected branches unless an environment variable is set.
  • PostToolUse on Edit/Write: run a formatter against any file the agent modified.
  • Stop: if the agent ended a session with a failed test, post a note to a Slack channel.

Hooks run outside the model. They are deterministic. That makes them ideal for the “never let the agent do X” cases where system prompts are not enough.

CLAUDE.md in the repo root

Every project we work on has a CLAUDE.mdat the root. Not as documentation, but as context that loads automatically at the start of every session. Ours contain: the stack, the conventions we care about, a one-sentence description of each major directory, and a list of “never do this” rules specific to the project.

The agent reads this first. It massively reduces the “please use Tailwind v4 syntax, not v3,” kind of corrections. Ten minutes of writing a good CLAUDE.md saves hours per month in session friction.

The /compact and /clear dance

Long sessions accumulate noise. /compact summarizes the conversation so far and keeps the summary as context. /clear throws it all away and starts fresh. The mistake we made for months: /clear-ing when we should have been /compact-ing. Compact keeps the shape of what you were doing without the token cost of replaying every file read. If a session is getting slow but you still want the context, compact first.

Plan mode for anything non-trivial

/plan(or Shift+Tab) puts the agent in a planning-only mode where it proposes changes without making them. For any task that will touch more than two files, we start in plan mode, read the plan, edit the plan, and then say “go.” The ratio of wasted work to useful work went way down once we made this a default.

The worst Claude Code session is the one where you watched it edit 12 files you did not want edited. Plan mode is the fix.

MCP servers for your actual stack

Model Context Protocol (MCP) lets Claude Code talk to external services: your database, your ticketing system, your cloud provider. We run MCP servers for BigQuery (so the agent can query our data warehouse directly) and for Linear (so it can read and update tickets). Once you have one MCP server wired up, you will want five. The productivity lift from giving the agent real tools is bigger than any prompt engineering trick.

Small things that compound

  • Esc stops the current action. Use it when the agent is headed somewhere you do not want. Do not sit there watching it finish.
  • ! at the start of a message runs a shell command and feeds the output into the conversation. Handy for ! git status, ! pwd, or anything else you want in context without explaining it.
  • @ inside a prompt references a file. Instead of pasting file contents, use @path/to/file.ts and the agent will read it on demand.
  • Set up a keyboard shortcut to drop Claude Code into your current terminal directory. We map it to Cmd-Shift-C. The muscle memory pays off.

What we'd do differently

If we were starting over, we would write our CLAUDE.md, set up three hooks, build two skills, and call the onboarding done before writing any real code with the agent. The tool rewards setup. We spent our first month using it as a fancy autocomplete and wondering why other teams seemed to be getting more out of it. They were. The difference was configuration.