Claude Code Has 15 Power Features. I Was Using 3.

Most developers use Claude Code like a fancy autocomplete. Type a prompt, get a response, maybe run a command.

That covers about 20% of what this tool actually does.

I stumbled into the other 80% after Boris Cherny (Anthropic engineer, one of the original Claude Code architects) posted a feature thread on X. My workflow hasn't been the same since. I went from ~15 manual context switches per hour to roughly 3.

Here's the full setup.

TL;DR: Claude Code ships with 15+ power features most developers never touch — teleport (move sessions between machines), remote-control (drive Claude from scripts), /loop (iterative refinement), /schedule (cron-like task scheduling), hooks (shell triggers on events), /batch (parallel task execution), worktrees (parallel git branches), /btw (background context injection), /voice (speak your prompts), --bare (pipe-friendly output), --add-dir (multi-repo context), --agent (subagent mode), /branch (safe experimentation), a Chrome extension (browser-to-editor bridge), and mobile coding (SSH from your phone). Together they cut my context-switching overhead by roughly 80%.

The Problem: Claude Code Has a Discoverability Problem

Claude Code is a terminal-based AI coding assistant from Anthropic. Most developers treat it as a chat interface — type a question, read the answer. That's like using Vim but never leaving insert mode.

I'd been using Claude Code for months before I realized I was barely scratching the surface. The docs are thorough but flat — every feature gets equal weight, so the genuinely transformative ones hide between basic usage instructions. Boris Cherny's thread changed that. He listed features I'd never seen in any tutorial. I tried them. Half became daily habits within a week.

The gap isn't capability — it's awareness. Claude Code is closer to an operating system than a chat interface, but almost nobody treats it that way.

Here's every feature I adopted, in the order they changed my workflow.

1. Teleport — Move Sessions Between Machines

Teleport lets you export a full Claude Code session on one machine and resume it on another, with complete context preserved. If you've ever spent 10-15 minutes re-explaining a complex debugging context after switching machines — that's the problem this kills.

Start debugging on your MacBook at a coffee shop. Need to continue on your desktop at home? Before teleport, that meant starting from scratch.

# On the source machine
claude --resume --export session.json

# On the target machine
claude --resume --import session.json

**The entire conversation context, tool state, and working memory transfer over.** Zero re-explanation time. I use this 2-3 times per week, and it saves me 10-15 minutes each time.

## 2. Remote-Control — Drive Claude From Scripts

Remote-control lets you send instructions to an already-running Claude Code instance from a second terminal or script. The running instance receives and executes the command without losing its current state.

bash

Terminal 1: Claude Code running normally

claude

Terminal 2: Send a command to the running instance

claude --remote "run the test suite and summarize failures"

I use this inside CI scripts and monitoring hooks. When a deploy finishes, a script sends Claude a remote command to review the diff. This is the feature that turns Claude Code from an interactive tool into a programmable one. Trigger it from cron jobs, webhook handlers, any shell script.

3. /loop — Iterative Refinement Without Babysitting

/loop tells Claude to repeat a task cycle until a condition is met. It runs the action, reads the output, makes changes, repeats. No input from you between iterations.

/loop "run pytest and fix failures until all tests pass"

Claude runs tests, reads failures, edits code, runs again. I've watched it clear 14 test failures in a single session without me touching the keyboard.

The key insight: give it a clear, binary exit condition. "Fix until tests pass" works. "Make the code better" doesn't.

Set it running. Go get coffee. Come back to green tests. Works about 70% of the time on first try for well-scoped failures.

4. /schedule — Cron Jobs for Your AI

/schedule registers recurring tasks that Claude executes at specified times or intervals. No external cron daemon required.

/schedule "every morning at 9am, check for new GitHub issues labeled 'bug' and summarize them"

I have three running:

• 9:00 AM: Summarize overnight GitHub activity
• 12:00 PM: Check CI pipeline status across repos
• 5:00 PM: Draft end-of-day status update

This replaced a Slack bot I was paying $12/month for. The summaries are better too — Claude has full repo context, so it references actual code, not just issue titles.

5. Hooks — Shell Commands on Events

Hooks execute shell commands automatically when Claude performs specific actions. Configure them in .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "echo 'Tool invoked: Bash' >> /tmp/claude-audit.log"
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "command": "prettier --write \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
      }
    ]
  }
}

**My most-used hook auto-formats every file Claude writes.** No more "can you run prettier on that?" after every edit. I also log every Bash command Claude runs — useful for auditing long sessions. Available events: `PreToolUse`, `PostToolUse`, `PreRequest`, `PostRequest`.

Five minutes of setup. Hours saved per week.

## 6. /batch — Parallel Task Execution

`/batch` runs the same task across multiple files or directories simultaneously, spawning independent Claude instances in parallel.

/batch "update the copyright year to 2026 in all LICENSE files" --dirs ~/Projects/*/

I used this to migrate 8 microservices from Express 4 to Express 5. **Total time: 23 minutes. Estimated sequential time: 4 hours.** Each service got its own Claude instance working independently.

The constraint: tasks need to be independent. If repo B depends on changes to repo A, run them sequentially.

## 7. Worktrees — Parallel Git Branches

Claude Code has first-class git worktree support. When you ask it to try an experimental approach, it creates a worktree instead of touching your current branch.

/branch experiment-new-parser

This creates a git worktree, switches Claude's context to it, and lets you experiment freely. **I use this every time I'm unsure about an approach.** Try it in a worktree. Works? Merge. Doesn't? Delete. You've lost nothing.

**I went from 2–3 experimental approaches per week to 8–10.** The safety net changes how you think.

## 8. /btw — Background Context Without Interrupting

`/btw` injects context into Claude's working memory without pausing or redirecting an in-progress task. Claude incorporates the information into subsequent decisions silently.

/btw the API rate limit was raised to 1000 req/min yesterday

**It's like whispering to a coworker while they're typing.** No "stop, let me tell you something, okay now continue" cycle. The context just gets absorbed.

Small feature. I use it 5-10 times per day. Eliminates a surprisingly persistent source of friction.

## 9. /voice — Speak Your Prompts

`/voice` activates speech input. Claude listens, transcribes, responds. No push-to-talk — it activates on command and listens until you stop.

/voice

When I'm pacing around thinking through architecture, typing breaks my flow. **The quality of my prompts went up when I started speaking them.** You naturally provide more context when talking — you explain the "why" more, which gives Claude better results.

Best for planning and high-level direction. For precise code edits, I still type.

## 10. --bare — Pipe-Friendly Output

`--bare` strips all formatting, markdown, and UI chrome from Claude's output. Raw text only. This makes Claude composable with standard Unix tools.

bash
claude --bare "what's the main export of src/index.ts" | xargs echo

This turns Claude into a proper Unix citizen. I use it in shell scripts constantly:

# Generate a commit message from staged changes
git diff --staged | claude --bare "write a conventional commit message for this diff"

No markdown, no explanations. Just the answer. Combine with `--agent` for fully non-interactive scripting.

## 11. --add-dir — Multi-Repo Context

`--add-dir` adds a second (or third) directory to Claude's context, letting it read files from multiple repositories in a single session.

bash
claude --add-dir ../backend-api

This eliminated my #1 source of bad suggestions. Claude would previously guess at API shapes instead of reading the actual backend code. Once I added the related repo, incorrect cross-repo suggestions dropped to near zero.

I permanently have --add-dir set for 3 repo pairs that always work together.

12. --agent — Subagent Mode

--agent runs Claude non-interactively as a subprocess — give it a task, it executes, returns structured output. Makes Claude composable inside larger automation pipelines.

claude --agent "analyze this codebase and output a JSON summary of all API endpoints" \
  --output endpoints.json

**This is how I built my internal documentation pipeline.** A shell script runs `--agent` across each service, collects JSON outputs, merges them into a single API catalog. Zero manual effort. Runs in CI on every merge to main.

## 13. /branch — Safe Experimentation

Different from worktrees — `/branch` creates a named branch and immediately begins working on it within the current directory context.

/branch feature/add-caching

Claude creates the branch, switches to it, and all subsequent work happens there. Review and merge normally when done. **The safety net makes me say "try it" instead of "let me think about it more."** I experiment 3x more because the cost of failure is a single `git branch -D`.

## 14. Chrome Extension — Browser-to-Editor Bridge

The Claude Code Chrome extension creates a direct channel from your browser to your running Claude Code session. Send errors, console output, network requests directly — no copy-pasting.

**Click the extension icon, select the error, done.** It lands in Claude's context with full browser environment info — URL, console logs, network requests. Stack traces that used to take 4-5 copy-paste cycles now transfer in one click.

I use this for frontend debugging daily. Install from the Chrome Web Store — search "Claude Code."

## 15. Mobile Coding — SSH From Your Phone

SSH into your dev machine from a mobile terminal app, run Claude Code, use `/voice` for input. Emergency fixes from anywhere.

bash

From phone terminal (Termius, Blink, etc.)

ssh dev-machine
cd ~/Projects/my-app
claude
/voice

I've merged hotfixes from a grocery store parking lot. Comfortable? No. Functional in emergencies? Absolutely. SSH + /voice means you barely type on the phone keyboard. Speak the problem, Claude fixes it, review the diff, approve.

What I'd Do Differently

1. Set up hooks on day one. I wasted weeks manually formatting files and auditing commands. Five minutes of config would have saved hours.
2. Use /batch earlier for migrations. I did three migration projects sequentially before learning /batch existed. Those 12 hours could have been 2.
3. Make --add-dir permanent sooner. Half my bad suggestions in the first month came from Claude not seeing the other repo in a pair.

The Numbers

Metric	Before	After
Context switches/hour	~15	~3
Time to re-explain context	10-15 min	0 (teleport)
Migration time (8 services)	~4 hours	23 min (/batch)
Monthly Slack bot cost	$12	$0 (/schedule)
Experimental branches/week	2-3	8-10 (/branch)
Frontend debug copy-paste cycles	5-6/day	0 (extension)

Feature	Daily Use	Impact
/loop	3-5x	High — saves 30+ min/day
/btw	5-10x	Medium — reduces friction
hooks	Always on	High — auto-formatting alone saves 15 min/day
--add-dir	Always on	High — eliminates wrong-context suggestions
/voice	2-3x	Medium — better prompts when pacing
/batch	1-2x/week	High when used — massive time savings

FAQ

Do these features work on all plans?
Most features are available on all Claude Code plans. /schedule and /batch may have usage limits on lower tiers. Check the Claude Code documentation for current plan details — Anthropic updates tier limits frequently.

Can hooks run arbitrary scripts?
Yes. Hooks execute shell commands with full access to your environment. Powerful, but also dangerous — a misconfigured PostToolUse hook that exits non-zero can block Claude from completing writes. Test hooks in a scratch directory first.

Does /loop have a max iteration count?
You can set one: /loop --max 10 "fix tests". Without a limit, Claude keeps going until it succeeds or determines it's stuck. Most loops resolve within 5-8 iterations. --max 15 is a reasonable safety ceiling.

Is mobile coding actually practical?
For emergencies under 20 minutes, yes. Anything longer, no. Latency and a 6-inch screen make extended sessions painful. But for "the deploy is broken and I'm not at my desk" — it's saved me twice this year.

How does --add-dir handle large repos?
Claude doesn't load the entire directory into memory. It indexes file paths and reads on demand. I've used --add-dir with repos over 50K files without noticeable slowdown.

Try It Yourself

Pick one. Just one. Today.

1. Type /voice and say something instead of typing it.
2. Add a formatting hook: create .claude/settings.json with a PostToolUse hook for your formatter.
3. Run /loop "run tests and fix failures" on a repo with known test failures.
4. Use --add-dir to connect two repos that work together.
5. Next time you switch machines, teleport your session instead of starting fresh.

One feature per day. Two weeks from now, you'll wonder how you worked without them.

Over to You

Which feature surprised you most? Drop it in the comments. My bet: /btw and hooks are the sleepers — they sound minor, but the cumulative savings across a full workday are not.

Bookmark this — you won't remember all 15, but you'll want to look them up when the situation fits.

If this was useful, follow me @TheStack_ai for more posts about building with AI tools in production. Not theory — just what actually works at the keyboard.

---

I build AI-powered developer tools and write about the engineering behind them. Currently shipping an AI-native app with Claude Code as my primary development environment. Daily user since public launch. 3 production services migrated using these techniques.