How to Use Claude Code Like a Power User

Claude Code is Anthropic's agentic coding tool. You install it with one command, run claude inside a project folder, and describe the work in plain English. It reads the repo, proposes a diff, and waits for your approval before writing. As of August 2026 the default model is Sonnet 5.

Updated August 3, 2026 · by the AITerm team

Here's the thing. Most Claude Code tutorials are a feature tour. Features are the easy part.

Learning how to use Claude Code well is mostly about what a tour skips: the agent works while you are not looking, and you have no idea whether it is thinking, waiting for you, or quietly stuck. We build a terminal manager for exactly that problem, so this guide is written from the side of the screen where you watch six sessions at once. Everything below is what we actually run.

What Claude Code is, in one paragraph

Strip the positioning and what is Claude Code, exactly? A command line agent that edits your codebase. It finds relevant files across the project on its own, plans a change, shows you the diff, and applies it once you approve. You do not paste files into a chat window.

It runs in the terminal, but also as a desktop app, in VS Code and JetBrains, on the web at claude.ai/code, in Slack, and in CI through GitHub Actions and GitLab. The Claude Code CLI is the reference implementation and the one every other surface is measured against, which is why this guide stays there.

You are probably thinking this is autocomplete with extra steps. It is not, and the difference is the loop: Claude Code runs commands, reads their output, and corrects itself. It runs your tests, then reads the stack trace.

That feedback loop is why it can finish a task you would otherwise babysit line by line. It is also why it can burn twenty minutes going the wrong direction on a vague instruction.

How do you install Claude Code and log in?

How to install Claude Code: one command on macOS, Linux and WSL, then run claude in a project folder. Login happens in the browser on first run, and the credentials are stored so you never do it again. The whole thing takes under three minutes on a normal connection.

# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# or, if you live in Homebrew
brew install --cask claude-code

claude --version     # prints a version followed by (Claude Code)
cd ~/code/my-project
claude               # browser opens once for login

On Windows, PowerShell takes irm https://claude.ai/install.ps1 | iex and WinGet takes winget install Anthropic.ClaudeCode. Install Git for Windows alongside it, otherwise Claude Code falls back to PowerShell as its shell tool and half the commands it writes will be wrong.

Your first hour, five prompts that teach the loop

Start by asking questions, not edits. The point of hour one is calibrating how much the agent already understands about your repo before you let it change anything. Anthropic's own quickstart opens the same way.

Ask what does this project do, then where is the main entry point, then explain the folder structure. Read the answers as a code review of your own architecture. If Claude gets your layout wrong, a human joining your team would have too, and that tells you what belongs in CLAUDE.md.

Then the first real edit. Be specific: not "fix the bug", but "fix the login bug where users see a blank screen after entering wrong credentials". Vague prompts are the single biggest cause of the twenty-minute wrong-direction run we mentioned earlier.

> what does this project do?
> where does the auth flow start, and what calls it?
> add input validation to the user registration form
> run the test suite and fix what breaks
> review my changes and tell me what you would reject

That last one is underrated. Turns out asking the agent to reject its own work catches a surprising amount of half-finished code, because the review prompt does not carry the sunk cost of the implementation prompt.

What do you do when a session goes wrong?

Press Escape twice. Claude Code snapshots state before it changes things, and the double Escape rewinds to an earlier point in the session rather than leaving you to unpick edits by hand. That is the first reflex to build, before any prompting technique.

The second reflex is knowing which kind of wrong you are looking at, because the fixes do not overlap. A session can go wrong in three ways, and telling them apart takes about ten seconds once you know what to look for.

The agent misunderstood the goal: that is a prompt problem, and rewinding plus one more specific sentence fixes it. The agent understood but keeps breaking a convention: that is a CLAUDE.md problem, or a hook if you have already written the rule twice. The agent was fine for twenty turns and then started making sloppy edits: that is a context problem, and no amount of rephrasing will save it. Clear and restart.

Esc Esc          # rewind to an earlier state in this session
/context         # is the window nearly full? that is your answer
/clear           # start clean, CLAUDE.md is reloaded from disk
git diff         # the only opinion that is not the model's

git restore .    # when the diff is unsalvageable, and it happens

Honestly, the failure mode we see most often in our own repo is none of those. It is approving a plan that was subtly wrong because the plan looked well written. Long, confident plans get skimmed. That is a human bug, and the only patch we found is reading the file list in a plan before reading the prose.

Write the CLAUDE.md you will actually maintain

A CLAUDE.md file is a markdown file of persistent instructions loaded into context at the start of every session. It goes in ./CLAUDE.md or ./.claude/CLAUDE.md for the team, ~/.claude/CLAUDE.md for you, and ./CLAUDE.local.md for machine-local notes you gitignore. Anthropic's docs target under 200 lines per file.

Our first CLAUDE.md was over 400 lines. The agents ignored roughly half of it and we could not tell which half, because a long file does not fail loudly, it just quietly stops being followed. We deserved that one.

The version that works for the AITerm repo is short and every line changes behaviour. It carries the build command, the localisation rule (every visible string goes through L("key") and must exist in seven languages), and the one hard prohibition that matters in an agent-heavy repo: never push without an explicit ask.

# AITerm project rules

## Build & test
- Build: ./build.sh (Swift Package, signed AITerm.app)
- Never run git push without an explicit ask

## i18n
- Every visible string goes through L("key")
- A key must exist in all 7 Localization/L10n+*.swift files

## Performance
- No continuous animations, no idle timers, no gratuitous blur

The short version: if a rule does not change what the agent does, cut it. Directory listings and dependency lists are the usual offenders, because Claude can read those from the codebase faster than you can maintain them in prose.

When a project outgrows one file

Two escape hatches exist and they are not interchangeable. Imports with @path/to/file pull another file into the same startup context, so they help organisation and do nothing for context size. Rules in .claude/rules/ can carry a paths frontmatter glob, so they only load when Claude touches matching files.

---
paths:
  - "Sources/AITerm/Localization/**/*.swift"
---

# Localization rules
- Register: informal in fr/es/de, "você" in pt
- Never introduce U+2014 anywhere in the project

There is also auto memory, which is Claude writing its own notes per repository into ~/.claude/projects/<project>/memory/. Only the first 200 lines or 25KB of its MEMORY.md index load at session start. Run /memory once a month and delete what is stale, because nobody else will.

What are skills, subagents, hooks and MCP?

Four extension layers, and the fastest way to pick is by asking what you need guaranteed. A hook is deterministic shell code and cannot be talked out of running. A skill is a folder Claude loads on demand.

A subagent is a fresh context window. MCP is how Claude reaches systems outside your filesystem.

Look, the mistake almost everyone makes here is reaching for a subagent when a skill would do. Subagents are for isolation, not for organisation. If you just want a repeatable procedure, a skill costs you nothing until the moment Claude decides it is relevant, and it keeps your main context clean.

Hooks are the layer people discover last and regret not using first. A PreToolUse hook that blocks writes to Sources/AITerm/Localization/ unless all seven files are touched is worth more than three paragraphs of CLAUDE.md prose asking nicely for the same thing. Instructions are context, hooks are enforcement.

Plugins bundle all of that into one versioned install through /plugin. Useful for teams, mostly noise for solo work until your setup stabilises.

Plan mode and permission modes, the two switches that matter

Shift+Tab cycles Claude Code's permission modes, and that single shortcut changes your day more than any prompt technique. Default mode asks before every change. acceptEdits stops asking. plan lets Claude research and propose without writing a single file.

Plan mode uses a read-only subagent that explores the codebase before it answers, so it physically cannot edit anything while it thinks. Use it for anything touching more than three files, anything in a payment path, and anything you would want a human to review before it starts.

And yes, we know the contrarian take is unpopular: plan mode by default is wrong. On a two-file change it adds a round trip and a wall of text you will skim, which trains you to skim the plans that actually matter. Reserve it and it stays useful.

How do you keep context from eating your session?

Context, not tokens, is what ends most sessions badly. Every file read, every command output and every CLAUDE.md line sits in a finite window, and the agent gets measurably worse as that window fills. Two commands manage it: /context to see the damage, /clear to reset.

Run /context before you start anything long. It lists what is loaded, including which memory files made it in, which is also the fastest way to debug a CLAUDE.md that is being ignored (if it is not in that list, Claude never saw it).

Then the habit that saves the most: one task, one session. When you switch from a refactor to a bug in an unrelated module, /clear costs you nothing and buys back the entire window. Project-root CLAUDE.md is re-read from disk after compaction, so your rules survive.

Honestly, this is where the METR result becomes uncomfortable. Their randomized trial of 16 experienced open-source developers on 246 tasks found people were 19% slower with early-2025 AI tools, while those same people estimated afterwards that they had been 20% faster.

METR now flags that result as historical, and the tooling has moved a long way since. The lesson that survived is the one about perception. You are a bad judge of your own speed while an agent is running, so measure with commits and cycle time instead of feel.

How much does Claude Code cost and when do limits hit?

There is no free tier. Claude Code needs a Claude subscription, a Console account with prepaid credits, or access through Bedrock, Google Cloud or Microsoft Foundry. Pro at 20 dollars a month is the entry point, and Anthropic doubled the usage limits on all paid plans on 6 May 2026.

Two windows govern you at once: a rolling five-hour window for bursts and a weekly cap on active compute. The same bucket is shared with claude.ai chat and Cowork, so an afternoon of chatting eats the evening you planned for a refactor.

That shared bucket is exactly why we built quota gauges into AITerm rather than leaving them on a web page. The official usage windows sit pinned under your sessions, with a notification at 75% and again at 90%. Nothing is more expensive than a two-hour agent run that dies at minute 95 because you had no idea where you stood.

Which model, and when

Sonnet 5 is the default in Claude Code and handles most of the work. Opus 5, released 24 July 2026, is the default on Max and the one to switch to for architecture, gnarly debugging and large refactors. On the API side Sonnet 5 runs at $2 per million input tokens and $10 output at its introductory rate through 31 August 2026, against $5 and $25 for Opus 5.

Switch with /model inside the session. Picking one model for the whole day is a habit left over from the chat era.

Running more than one session without losing the thread

Git worktrees are the answer to parallel sessions: separate working directories on separate branches, sharing one repository history, so two agents never fight over the same file. Claude Code has first-class support and a docs page dedicated to it.

git worktree add ../proj-auth   -b feature/auth
git worktree add ../proj-tests  -b chore/tests

cd ../proj-auth  && claude    # session 1
cd ../proj-tests && claude    # session 2

git worktree remove ../proj-tests   # the step everyone forgets

Published setups converge on two to four concurrent sessions as the practical ceiling, and the reason is not machine power. It is review bandwidth. Rebase between worktrees instead of merging, because a linear history is easier for the next session to read in git log.

Fair question: why does the ceiling land so low when the hardware is idle? Because the cost of parallelism is not CPU, it is knowing which of the six panes is waiting for an answer. That is a display problem, and it is the one we spend our days on.

One rule saves more pain than the worktrees themselves: commit at session boundaries, not at task boundaries. When a session ends you commit, even if the work is half done, because the next session reads git log to reconstruct what happened. Rebase rather than merge for the same reason. Merge commits make that history harder for the agent to follow than it is for you.

Does Claude Code only run in the terminal?

No. The same agent runs as a desktop app on Mac and Windows, inside VS Code and JetBrains IDEs, on the web at claude.ai/code, in Slack, and headless in CI through GitHub Actions and GitLab CI/CD. The terminal CLI is where features land first and where every other surface is measured against.

The IDE extensions are the right pick when you are reviewing diffs constantly and want them inline. The web and Slack surfaces are for kicking off work away from your machine. GitHub Actions is where claude -p stops being a novelty: one non-interactive query, output to stdout, exit code you can branch on.

# a pre-push check that costs one API call
claude -p "Read the staged diff. Reply BLOCK if any user-facing
string bypasses L('key'), otherwise reply OK." | grep -q OK

So, which one should you live in? For a single task at a time, the IDE extension is hard to beat. The moment you run two agents or more, you are back in a terminal, because that is the only surface where several sessions sit side by side and stay visible at once.

The terminal is the part nobody optimises

Your agent output streams through a terminal emulator, and most of them were designed for a human typing one command at a time. Under six agents streaming at once, the difference between a native renderer and a bundled browser engine stops being an aesthetic argument.

Size is a proxy, not the point. The point is what the renderer does when four panes dump output at once: a native text engine draws it, a web stack queues your keystrokes behind its own repaint. We measured 20 panes streaming agent output on an M2 Air and stayed inside a memory footprint our old Electron setup passed before lunch.

Our first attempt at reading agent state was worse than the terminal problem. We parsed the scrollback with regexes to guess whether Claude was working or waiting, and it broke on the second Claude Code update. We deserved that too. The version that works reads Claude Code and Codex directly, with no plugin to install inside the agent.

The setup we actually run

One workspace per project, agents in side-by-side panes, quota gauges under them, and a status colour per session: working, waiting, done, failed. That is the whole cockpit, and it exists because piloting agents is a monitoring job disguised as a coding job.

Concretely, on the AITerm repo: Claude Code in one pane on the feature branch, a second session in a worktree on tests, the dev server in a third, and the seven-language localisation pass as a skill rather than a paragraph of CLAUDE.md prose. The anonymous daily ping we ship tells us most people settle around three concurrent sessions, with a long tail well above that.

Nothing above requires our app. Worktrees, plan mode, short CLAUDE.md files and one task per session work in any terminal. The app removes the part where you alt-tab to find out who needs you, which stops being a small thing somewhere around the fourth agent.

That's it. Now go run /context before your next long task, and see how full that window already was.

Going further

Sources

1. Claude Code Quickstart, Anthropic docs, 2026: install commands, login, essential commands, permission modes.
2. How Claude remembers your project, Anthropic docs, 2026: CLAUDE.md locations, the 200-line target, imports, .claude/rules/, auto memory.
3. Run parallel sessions with worktrees, Anthropic docs, 2026.
4. Introducing Claude Sonnet 5, Anthropic, 2026: default model in Claude Code, introductory API pricing.
5. Stack Overflow Developer Survey 2025, AI section: 84% adoption, 29% trust in accuracy.
6. Developers remain willing but reluctant to use AI, Stack Overflow blog, 2025.
7. Measuring the impact of early-2025 AI on experienced open-source developer productivity, METR, 2025: 16 developers, 246 tasks, 19% slower.
8. We are changing our developer productivity experiment design, METR, 2026: why the 2025 result is now labelled historical.
9. Claude Code 101, Anthropic Courses, 2026.
10. Claude Code rate limits and usage quotas explained, TrueFoundry, 2026: five-hour rolling window and weekly cap, shared bucket.