# Claude Code Power User: /effort, /context, /loop, and the Slash Commands That Actually Matter

Canonical: https://clawdocx.com/blog/claude-code-effort-context-slash-commands-2026
Author: Theo Marsh
Published: 2026-03-16
Updated: 2026-03-16

> A practical guide to Claude Code's most useful slash commands: /effort for analysis depth, /context for memory issues, /loop for recurring tasks, and /simplify.

## The Commands That Change How You Work

Claude Code has accumulated a lot of slash commands. Most of them you'll never touch. But a handful — shipped in early 2026 — fundamentally change how you interact with the tool.

This guide covers the ones worth learning, in order of impact.

---

## /effort — Control How Hard Claude Thinks

**Shipped:** v2.1.76 (March 2026)

Not every question needs deep analysis. A quick rename doesn't need the same thinking depth as a complex refactoring plan. `/effort` lets you match Claude's analysis level to the task.

### Three Levels

| Level | Symbol | When to Use |
|-------|--------|-------------|
| **Low** | ○ | Quick answers, simple edits, routine operations |
| **Medium** | ◐ | Standard development work (default for Opus 4.6) |
| **High** | ● | Deep debugging, architecture decisions, security audits |

### How to Use It

```bash
# Set effort for the rest of the session
/effort low
/effort medium
/effort high

# One-shot maximum effort (single turn only)
# Just include "ultrathink" in your prompt:
ultrathink — analyze the race condition in the payment processing pipeline
```

### Why It Matters

- **Low effort** is faster and cheaper. Use it for file lookups, simple formatting, and quick questions.
- **High effort** produces better analysis on complex problems. The difference is real — Claude spends more time reasoning before responding.
- **Ultrathink** triggers maximum reasoning depth for a single turn, then reverts to your session default.

> **Tip**
>
> The "max" effort level was removed in March 2026. Use "ultrathink" in your prompt when you need maximum depth — it's more flexible than a persistent setting.

### Cost Impact

Higher effort = more tokens = higher cost. On a Max plan you won't notice, but if you're on API billing or a Team plan with limits, keep effort at medium for routine work and bump it up selectively.

---

## /context — Debug Your Context Window

**Updated:** v2.1.74 (March 2026)

When Claude starts ignoring your CLAUDE.md rules or producing lower-quality output, the issue is usually context. Either your context window is filling up, or the wrong things are consuming space.

`/context` now gives you **actionable diagnostics**:

```bash
/context
```

It shows:
- **Total context usage** — how much of the window is consumed
- **Top consumers** — which tools, files, and memory entries use the most space
- **Memory bloat warnings** — if auto-memory is eating too much context
- **Optimization suggestions** — specific steps to free up space

### When to Use It

- Claude stops following CLAUDE.md rules → check if context is full
- Responses get shorter or lower quality → context might be compacting
- You're in a long session and things feel off → run `/context` to see where you stand

### The 1M Context Advantage

With Opus 4.6's 1 million token context window (Max/Team/Enterprise), context pressure is much less of an issue than it used to be. But even 1M tokens fill up on large projects. `/context` helps you stay aware.

---

## /loop — Recurring Tasks Without Leaving Claude

**Shipped:** v2.1.71 (March 2026)

`/loop` turns Claude Code into a lightweight cron-like system. Define an interval and a prompt, and Claude executes it repeatedly.

### Syntax

```bash
/loop <interval> <prompt>
```

### Real Examples

```bash
# Monitor deployment status every 5 minutes
/loop 5m check if the Vercel deployment succeeded

# Run tests every 30 seconds during active development
/loop 30s run npm test -- --bail

# Check for new GitHub issues every hour
/loop 1h check for new issues on the repo and summarize any new ones

# Watch error logs
/loop 2m tail the last 20 lines of logs/error.log and flag anything new
```

### How It Works

- The loop runs as long as your session is open
- Each iteration is a new prompt to Claude — it has full tool access
- Output appears in your session like any other response
- Stop it by closing the session or disabling with `CLAUDE_CODE_DISABLE_CRON=true`

### Best Use Cases

- **CI/CD monitoring** — check deployment status during a rollout
- **Test-driven development** — run tests automatically after every change
- **Log watching** — monitor error logs while debugging
- **Health checks** — verify services are running during development

> **Note**
>
> /loop is session-level only — it doesn't persist across sessions. For persistent scheduled tasks, use OpenClaw's cron system or your OS-level cron.

---

## /simplify — Clean Up Code

**Shipped:** v2.1.63 (February 2026)

Select a block of code and `/simplify` reduces complexity while maintaining behavior:

```bash
/simplify
```

Claude analyzes the selected code and suggests simpler alternatives — removing nested conditionals, extracting functions, replacing verbose patterns with cleaner idioms.

This is particularly useful after a long coding session where Claude has been adding features incrementally and the code has accumulated layers of complexity.

---

## /batch — Operations Across Multiple Files

**Shipped:** v2.1.63 (February 2026)

`/batch` lets you apply an operation to multiple files at once:

```bash
/batch add TypeScript strict null checks to all API route files
/batch update the copyright header in all .ts files
/batch add error handling to all database query functions
```

Claude identifies the matching files, applies the change to each one, and reports results. Much faster than asking about each file individually.

### When to Use /batch vs Manual Requests

- **Use /batch** for uniform changes across many files (headers, imports, patterns)
- **Use manual requests** for changes that need per-file context (refactoring a specific function)

---

## /voice — Talk to Your Code

**Shipped:** v2.1.68 (March 2026, rolling out gradually)

Push-to-talk voice input. Hold spacebar, speak, release. Claude transcribes and executes.

```bash
/voice
```

### Customizing the Push-to-Talk Key

Edit `keybindings.json`:

```json
{
  "voice:pushToTalk": "meta+k"
}
```

### 20 Supported Languages

English, Spanish, French, German, Italian, Portuguese, Japanese, Korean, Chinese, Hindi, Russian, Polish, Turkish, Dutch, Ukrainian, Greek, Czech, Danish, Swedish, Norwegian.

Transcription is optimized for technical terms and repository names — so saying "React useState hook" or "Prisma migrate dev" works reliably.

> **Note**
>
> Voice mode is currently rolling out to ~5% of users. If you don't see it, update to the latest Claude Code version and check back.

---

## /color — Visual Session Separation

**Shipped:** v2.1.75 (March 2026)

When running multiple Claude Code sessions in different terminals, they all look the same. `/color` sets a color for the prompt bar:

```bash
/color blue
/color red
/color green
```

Simple but surprisingly useful when you've got 3 terminals open for frontend, backend, and tests.

---

## /model — Switch Models Mid-Session

Not new, but updated in March 2026 to show human-readable labels instead of raw model IDs:

```bash
/model
```

The picker now shows which model is currently active and lets you switch without restarting the session. Useful for dropping to Sonnet for simple tasks or bumping to Opus for complex ones.

---

## /copy — Extract Code Blocks

```bash
/copy
```

Shows an interactive picker of all code blocks in Claude's last response. Select one and it copies to your clipboard. The "Always copy full response" option grabs everything.

---

## Command Cheat Sheet

| Command | What It Does | When to Use |
|---------|-------------|-------------|
| `/effort` | Set analysis depth (low/medium/high) | Match thinking to task complexity |
| `/context` | Debug context window usage | When Claude ignores rules or quality drops |
| `/loop` | Recurring task every N minutes | CI monitoring, test watching, log tailing |
| `/simplify` | Clean up selected code | After long implementation sessions |
| `/batch` | Apply change to multiple files | Uniform updates (headers, imports, patterns) |
| `/voice` | Push-to-talk voice input | Hands-free coding, accessibility |
| `/color` | Color the prompt bar | Multi-session visual separation |
| `/model` | Switch models mid-session | Cost optimization, task matching |
| `/copy` | Copy code blocks to clipboard | Extracting Claude's output |
| `/memory` | View/manage auto-memory | Periodic cleanup |
| `/agents` | Manage sub-agents | Create or edit custom agents |
| `/hooks` | Manage hooks | Set up automation |
| `/rename` | Rename the session | Organization when resuming later |

---

## For OpenClaw Users

When running Claude Code through OpenClaw's ACP bridge:

- **Slash commands work inside Claude Code** — type them in the Claude Code terminal, not in your OpenClaw chat
- **From OpenClaw chat**, steer the session naturally: "set effort to high" or "start a loop checking tests every minute" — Claude Code interprets these as it would any prompt
- **`/loop` is session-scoped** — for persistent scheduled tasks, use OpenClaw's `/cron` system instead

---

## Start Here

1. Set `/effort low` for quick tasks, bump to high for complex ones
2. Run `/context` when things feel off
3. Try `/loop 1m run tests` during your next active development session
4. Use `/batch` next time you need to update a pattern across files

These commands are the difference between using Claude Code and *driving* Claude Code. Learn them once, use them every session.

---

*For advanced workflow patterns, team configurations, and Claude Code optimization strategies, check out the premium guides on ClawDocx.*