Claude Code is an agentic coding tool that lives in your terminal, reads your codebase, edits files, and runs commands on your behalf. The thing that separates a casual user from a power user is not the model. It is knowing the commands that steer it. The right command at the right moment switches models, recovers from a bad turn, fans work out across a dozen background agents, or ships a reviewed pull request without you touching the keyboard much.

There are two families to learn. CLI commands and flags run in your shell when you start Claude Code (think claude -p, claude --resume, claude --model). Slash commands run inside a live session and start with a forward slash (think /clear, /compact, /code-review). This guide walks through the commands that matter day to day, with copy-paste examples for each, and ends with real workflows that chain them together.

Everything here is based on the official Claude Code reference as of June 2026 (Claude Code v2.1.x). Availability of a few commands depends on your platform, plan, and environment, so if a command in this guide does not appear when you type /, that is expected and noted where relevant.

1How Claude Code Commands Work

A slash command is only recognized at the start of your message. Type / to open the menu of every command available to you, or type / followed by a few letters to filter. Anything you type after the command name is passed to it as arguments, so /plan fix the auth bug enters plan mode and immediately seeds it with that task.

CLI flags work the other way around. You set them when you launch Claude from your shell, and they configure the session before it starts. The two families overlap on purpose: you can launch with claude --model opus or switch later with /model; you can start in plan mode with claude --permission-mode plan or drop into it later with /plan.

2Starting, Piping & Resuming Sessions (CLI)

These are the terminal commands you reach for before a session even begins. The most useful trick here is -p (print mode), which runs a query and exits, making Claude Code scriptable and pipeable like any other Unix tool.

# Interactive session in the current repo
claude

# Start with an initial prompt
claude "explain what this project does"

# One-shot query via the SDK, then exit (great for scripts)
claude -p "summarize the changes in the last commit"

# Pipe content straight into Claude Code
cat error.log | claude -p "what is causing these errors?"

# Continue the most recent conversation in this directory
claude -c

# Continue non-interactively (CI-friendly)
claude -c -p "check for type errors and list them"

# Resume a specific session by name or ID
claude -r "auth-refactor" "finish wiring up the login form"

Naming sessions pays off fast. Launch with -n to label a session so you can find it later in the /resume picker and in your terminal title.

# Give the session a memorable name
claude -n "payment-webhooks"

# Open the interactive session picker
claude --resume

# Resume but fork into a new session ID (keeps the original intact)
claude --resume payment-webhooks --fork-session

# Resume sessions linked to a pull request
claude --from-pr 1423

# Update to the latest version
claude update

3The Daily Drivers: Context & Model Control

These are the slash commands you will use in almost every session. Master these five and most of Claude Code clicks into place.

The most common mistake new users make is treating /clear and /compact as the same thing. They are not. Use this rule of thumb:

For model and effort, the interactive pickers are worth knowing. Running /model with no argument opens a picker; press s on a row to switch for the current session only without changing your default. Running /effort with no argument opens a slider you nudge with the arrow keys. Both take effect immediately without waiting for the current response to finish.

> /model opus            # switch to Opus and make it the default
> /effort high           # spend more reasoning on a hard problem
> /effort low            # save tokens on a trivial change
> /context               # see what is eating the context window
> /compact focus on the database migration plan
> /plan refactor the payment module to use Stripe webhooks

4Reviewing & Shipping Code Safely

Before you ship, Claude Code gives you a layered set of review commands. Think of them as moving from cheap and local to deep and thorough. Start with a diff, run a review, then escalate only if the change warrants it.

• /diff opens an interactive diff viewer for uncommitted changes and per-turn diffs. Use left and right arrows to switch between the git diff and individual Claude turns, up and down to browse files.
• /code-review is a bundled skill that scans the current diff for correctness bugs plus reuse, simplification, and efficiency cleanups. Pass --fix to apply the findings to your working tree, or --comment to post them as inline GitHub PR comments.
• /code-review ultra runs a deep multi-agent review in the cloud (also reachable as /ultrareview).
• /simplify runs a cleanup-only review (reuse, simplification, efficiency, right level of abstraction) and applies the fixes, without hunting for correctness bugs.
• /security-review analyzes pending changes on the branch for vulnerabilities like injection, auth issues, and data exposure.
• /review reviews a pull request locally in your current session.

> /diff                       # eyeball what changed
> /code-review                # find bugs and cleanup opportunities
> /code-review high --fix     # higher effort, auto-apply the findings
> /security-review            # check for injection, auth, data exposure
> /code-review ultra          # deep cloud review for a risky change

5Parallel & Background Work

This is where Claude Code stops feeling like a chat box and starts feeling like an orchestration layer. These commands let you run work you are not actively watching, and split large changes across many agents at once.

The standout here is /batch. Hand it a codebase-wide instruction and it researches the repo, breaks the work into independent units, shows you a plan, and (once approved) spawns one background subagent per unit in an isolated git worktree. Each subagent implements its slice, runs tests, and opens a pull request. It requires a git repository.

# Large-scale parallel migration, one PR per unit
> /batch migrate src/ from class components to React hooks

# Keep working toward a condition across turns
> /goal all integration tests pass and the build is green

# Poll a long-running job without babysitting it
> /loop 5m check if the staging deploy finished

# Detach the session and keep it running in the background
> /background finish the test suite and open a PR

From the shell side, the claude agents command opens a view to monitor and dispatch these parallel background sessions, and claude logs <id> prints recent output from any of them. You can also start a session directly in an isolated worktree:

# Start in an isolated git worktree (keeps your main checkout clean)
claude -w feature-auth

# Monitor all background sessions
claude agents

# Tail the output of one background session
claude logs 7c5dcf5d

# Start a session as a background agent and return immediately
claude --bg "investigate the flaky checkout test"

6Recovering & Debugging a Session

Things go sideways. A turn takes a wrong approach, an install breaks, or the model heads down a path you do not want. These commands pull you back.

The one to internalize is /rewind. Because Claude Code checkpoints both the conversation and your code, you can undo a bad turn including the file edits it made, then re-prompt with better instructions. It is far safer than letting the agent dig itself deeper, and it pairs naturally with plan mode: plan, execute, and if the result is wrong, rewind and adjust the plan.

> /rewind                 # roll code + conversation to a checkpoint
> /doctor                 # check the install, press f to auto-fix
> /debug the file watcher stops picking up changes after a while
> /release-notes          # see what changed in recent versions

7Custom Commands & Skills (Build Your Own)

The biggest unlock is writing your own commands. In current Claude Code, custom commands have been merged into skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create the /deploy command and work the same way. Your existing .claude/commands/ files keep working; skills just add more features.

Create a skill when you keep pasting the same checklist or multi-step procedure into chat. The directory name becomes the command you type, and the description helps Claude decide when to load it automatically. Here is a complete example that summarizes your uncommitted changes and flags anything risky:

---
description: Summarizes uncommitted changes and flags anything
  risky. Use when the user asks what changed or wants a commit message.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then
list any risks such as missing error handling, hardcoded values,
or tests that need updating. If the diff is empty, say so.

Two things make skills powerful. The backtick-bang syntax (!`command`) runs a shell command before Claude sees the prompt and inlines its output, so the model gets your actual live data instead of guessing. And $ARGUMENTS (or $0, $1 for positional args) captures whatever you type after the command name.

---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
allowed-tools: Bash(git push *) Bash(npm run *)
---

Deploy $ARGUMENTS to production:

1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded

Note disable-model-invocation: true. That frontmatter means only you can trigger the skill with /deploy; Claude will not decide to deploy on its own because your code looks ready. Use it for anything with side effects. The opposite, user-invocable: false, hides a skill from the menu so only Claude loads it as background knowledge.

8Permissions, MCP & Configuration

These commands control what Claude Code is allowed to do, what tools it can reach, and how it behaves. They matter most on shared repos and in automated pipelines.

Permission rules use a clear syntax. Bash(git log *) allows any git log call without prompting, Read allows the read tool outright, and a scoped deny like Bash(rm *) leaves the tool available but blocks matching calls. You can set these interactively with /permissions or pass them at launch.

# Pre-approve safe read-only tools, deny destructive ones
claude --allowedTools "Bash(git log *)" "Bash(git diff *)" "Read" \
       --disallowedTools "Bash(rm *)"

# Start in plan mode so nothing is edited until you approve a plan
claude --permission-mode plan

# Load MCP servers from a config file, ignoring all others
claude --strict-mcp-config --mcp-config ./mcp.json

# Append a house rule to the system prompt for this run
claude --append-system-prompt "Always use TypeScript and write tests"

9Power-User Workflows That Chain Commands

Individual commands are useful. Chaining them is where the real productivity lives. Here are four workflows that map to common engineering tasks.

Workflow 1: Onboard to an unfamiliar repo

claude                          # open a session in the repo
> /init                         # generate a starter CLAUDE.md
> /memory                       # refine the project memory
> /mcp                          # wire up any servers the repo needs
> /permissions                  # set approval rules before any edits

Workflow 2: Plan, build, and recover safely

> /plan add rate limiting to the public API
  # review the plan, then let it execute
> /context                      # watch the window if the task is long
> /compact focus on the rate-limit design decisions
  # if a turn goes wrong:
> /rewind                       # undo the code + conversation, re-prompt

Workflow 3: Review and ship a pull request

> /diff                         # see the full set of changes
> /code-review high --fix       # find and apply bug + cleanup fixes
> /security-review              # last pass for vulnerabilities
  # then ask Claude to commit and open the PR, or use a custom /ship skill

Workflow 4: Large migration across the codebase

> /batch migrate all API routes from Express to Fastify
  # approve the decomposed plan; each unit runs in its own worktree
$ claude agents                 # monitor the parallel sessions
$ claude logs <id>              # tail any unit that looks stuck
  # each unit opens its own PR when its tests pass

The pattern across all four: use plan mode and reviews to stay in control, use context commands to keep sessions healthy, and reach for background and batch commands only when the work is genuinely parallel. Resist the urge to fan out a task that is really sequential; the coordination overhead is not worth it.

10Why Lushbinary for AI-Powered Development

Knowing the commands is step one. Building a development process around them, with the right guardrails, custom skills, and team conventions, is where teams actually capture the productivity gains. That is what we do at Lushbinary.

If your team is adopting Claude Code or any agentic coding tool, we can help you go from "a few people use it" to a documented, guardrailed workflow the whole team trusts. See our guide to Claude Code Agent Teams for the next step in multi-agent development.