14 Claude Code Features Most Developers Haven't Tried Yet

Most developers who use Claude Code know the basics: point it at a codebase, ask a question, watch it read files and write code. But the tool has grown far beyond that. Features ship fast, documentation is scattered, and the result is that most people are using maybe 30% of what's available.

I built a reference page to catalog everything. Here's the distilled version — 14 features, organized by what they actually unlock.

Move sessions between devices

Claude Code sessions used to be stuck wherever you started them. Not anymore.

Teleport moves a cloud session to your local machine. Remote Control does the opposite — it connects your phone or browser to a locally running session so you can steer it from anywhere. I wrote about Remote Control in detail previously, but the short version is: your machine stays in control, the phone is just a window.

The underrated move here is enabling Remote Control globally in /config. Once you do that, every session is automatically controllable from your phone. No per-session setup required.

Cowork Dispatch is the non-coding counterpart. When you're away from your desk entirely, Dispatch lets you send tasks to your Claude Desktop instance — which executes them using your full MCP stack, browser, and filesystem — and sends results back to your phone. Think of it as: Remote Control is for when you're coding. Dispatch is for when you're not.

Automate recurring workflows

/loop runs any skill on a repeating timer. /schedule lets you set one-shot or recurring executions. Together they turn Claude into a background agent.

/loop 5m  /babysit          # check code review every 5 min
/loop 30m /slack-feedback    # open PRs from Slack feedback
/loop 1h  /pr-pruner         # close stale PRs every hour

The pattern is always the same: identify something you do manually on a cadence, write a skill for it, wrap it in a loop. Loops run locally and use your machine's permissions and MCP connections. They can run for up to a week continuously.

This is where Claude Code starts feeling less like a coding assistant and more like infrastructure.

Hooks: deterministic logic in the agent's lifecycle

Hooks are shell commands that Claude Code calls automatically at defined lifecycle events. They run outside the model — fully deterministic — which makes them perfect for things you don't want the model deciding on its own.

Four hook events exist:

• SessionStart — fires when Claude starts. Inject context, load config, set up the environment.
• PreToolUse — fires before every tool call. Log commands, gate dangerous operations, modify inputs.
• PermissionRequest — fires when Claude needs approval. Route approvals to Slack, WhatsApp, or a custom system.
• Stop — fires when Claude stops. Poke it to keep going, run cleanup, send notifications.

A practical example: log every bash command Claude runs.

# In your hooks config, on PreToolUse:
if [ "$TOOL_NAME" == "bash" ]; then
  echo "$(date): $TOOL_INPUT" >> ~/.claude/bash-audit.log
fi

If you're running Claude Code in any environment where auditability matters — regulated industries, shared team setups, production-adjacent workflows — hooks are non-negotiable.

Fork a session to explore alternatives

/branch creates an identical copy of your current session — same context, same file state — that evolves independently. This is how you safely explore "what if I try approach B" without losing your existing work.

# From inside a session:
/branch

# From the CLI with a known session ID:
claude --resume <session-id> --fork-session

I use this most often when I'm halfway through a refactor and realize there might be a cleaner approach. Instead of backing out, I fork, try the alternative, and compare. If the fork wins, I keep it. If not, I go back to the original.

Ask a side question without derailing the main task

/btw lets you inject a quick query while Claude is mid-task. It answers inline and then continues what it was doing.

# Claude is mid-refactor. You remember something:
/btw what's the difference between --hard and --soft in git reset?

# Claude answers, then continues refactoring

Small feature, surprisingly high impact. Before /btw existed, asking a side question would often shift Claude's focus away from the main task. Now you can tap it on the shoulder without breaking its flow.

Parallelize with worktrees and /batch

This is where Claude Code gets genuinely unusual.

Git worktrees let multiple checkouts of the same repo exist simultaneously. Claude Code has deep worktree support — start a session with claude -w and it creates a fresh worktree automatically. When you have 20+ agents running simultaneously, worktrees prevent them from clobbering each other's file state.

/batch takes this further. It's designed for large-scale changes that can be split into independent units. You describe the changeset, Claude interviews you for scope and constraints, then fans the work out to as many parallel worktree agents as needed — potentially hundreds.

1. You run /batch and describe the changeset
2. Claude interviews you for scope + constraints
3. Claude plans the decomposition
4. N worktree agents execute in parallel
5. Results are collected and merged

Ideal workloads: codebase migrations, renaming across hundreds of files, test generation at scale, API version upgrades, lint sweeps. The key constraint is that the work must be parallelizable — where agent A and agent B won't conflict.

Give Claude a browser

Claude produces better frontend work when it can see its own output. The Chrome extension (or the built-in browser in the Desktop app) closes this feedback loop.

Without a browser, Claude writes HTML/CSS/JS and hopes it looks right. With one, it writes code, screenshots the rendered result, compares to the spec, and iterates. Would you ask an engineer to build a website without letting them use a browser?

The Desktop app has the lowest friction here — it bundles a browser and can auto-start local dev servers with zero config. The CLI and VSCode routes require installing the Chrome extension and running the server manually.

The --bare flag for SDK usage

When you use claude -p (or the TypeScript/Python SDKs) programmatically, it scans the filesystem for CLAUDE.md files, settings, and MCP configs by default. In non-interactive usage, you almost always want to specify these explicitly.

# Default (slow — scans filesystem):
claude -p "do the thing"

# Bare (fast — you control everything explicitly):
claude -p "do the thing" --bare \
  --system-prompt "You are..." \
  --mcp-config ./mcp.json \
  --settings ./settings.json

This can speed up non-interactive SDK usage by up to 10x. Worth noting: the current scan-by-default behavior is considered a design oversight. A future version will flip the default to --bare. Opt in now.

Custom agents

Define agents with custom system prompts, tool sets, and MCP configs in .claude/agents/, then invoke them by name.

.claude/
  agents/
    security-reviewer.md
    doc-writer.md
    migration-helper.md

claude --agent=security-reviewer
claude --agent=doc-writer

This is how you go from "Claude Code is a general-purpose assistant" to "I have a team of specialized agents." Each agent gets its own persona, allowed tools, constraints, and tone. Security reviewers that are paranoid by design. Documentation writers that match your team's style guide. Migration helpers that know your stack's quirks.

Voice input

Voice input works across all Claude Code surfaces — CLI, Desktop, and mobile. It's not a novelty.

# CLI:
/voice        # then hold SPACE to speak

# Desktop app:
Click the voice button in the UI

Dictating long context dumps, architecture discussions, or nuanced requirements is often faster than typing. Speaking out loud also forces you to articulate the problem more clearly, which tends to produce better prompts.

I've found voice most valuable during planning sessions — when I'm thinking through an approach and want to dump raw context into Claude before asking it to structure things. The spoken-word version is almost always more detailed than what I would have typed.

The compound effect

None of these features exist in isolation. The real power comes from combining them:

• Write a custom agent for security reviews → wrap it in /loop to run every time a PR opens
• Use hooks to inject project context on SessionStart → then /batch a migration across the whole codebase
• Fork a session to try two approaches → use worktrees so both run in parallel without conflicts
• Start a voice planning session on your phone → teleport the session to your laptop when you're ready to code

Claude Code has quietly become something closer to an agent operating system than a coding assistant. Most of these features shipped in the last few months. If you haven't checked in recently, it's worth another look.