Skip to content
Lesson 11 of 14

Advanced Workflows

8 min read

Beyond Basic Interaction

You now know how to use Claude Code's individual features: skills, hooks, MCP servers, subagents, plugins, and checkpoints. This lesson focuses on the advanced workflows that emerge when you combine those features with Claude Code's deeper configuration options. These workflows are what separate casual users from power users who rely on Claude Code as their primary development tool.

Planning Mode

When you face a complex feature that touches multiple files, modules, or services, jumping straight into code is risky. Planning mode lets Claude explore your codebase, design an approach, and get your approval before writing a single line of code.

Activate planning mode with:

/plan

Or use it directly with a prompt:

/plan Add a rate limiting system to the API. It should support per-endpoint limits,
      use Redis for distributed state, and include a bypass mechanism for admin tokens.

In planning mode, Claude operates in a read-only exploration phase. It reads files, searches for patterns, maps dependencies, and builds a mental model of the relevant parts of your codebase. Then it presents a structured plan:

Plan: Add Rate Limiting System

1. Create middleware at src/middleware/rate-limiter.ts
   - Accept config per route (window, maxRequests)
   - Use Redis for distributed counting
   - Check X-Admin-Token header for bypass

2. Add Redis client at src/lib/redis.ts
   - Connection pooling with ioredis
   - Graceful fallback if Redis is unavailable

3. Update src/routes/index.ts
   - Apply rate limiter to all /api/* routes
   - Set per-endpoint limits in route config

4. Add tests at tests/middleware/rate-limiter.test.ts
   - Test rate exceeded response (429)
   - Test admin bypass
   - Test Redis failure fallback

Estimated files: 4 new, 1 modified

You review the plan, suggest changes, or approve it. Only after approval does Claude start writing code. This prevents the wasted effort of building something that does not match your architectural intent.

Try this: use /plan for your next multi-file feature. Notice how the plan catches architectural decisions you might have missed if you went straight to coding.

Permission Modes Deep Dive

Claude Code offers six permission modes that control how much autonomy Claude has. Choosing the right mode for each situation is a key skill.

default

Claude asks permission for everything -- file reads, writes, and command execution. This is the learning mode. Use it when you are new to Claude Code or working in an unfamiliar codebase.

acceptEdits

Claude automatically approves file edits but still asks before running shell commands. This is the daily development mode for most practitioners. You trust Claude to write code but want to review any commands it runs.

claude --permission-mode acceptEdits

plan

Read-only mode. Claude can explore the codebase and create plans but cannot modify any files or run commands. Perfect for architecture reviews and codebase audits.

claude --permission-mode plan

auto

Full autonomy with a background safety classifier. Claude makes its own decisions about reads, writes, and commands, but a safety system blocks potentially dangerous operations (like rm -rf / or force-pushing to main). This is the mode for trusted tasks where you want Claude to work independently.

claude --permission-mode auto

dontAsk

Accept everything without asking. Similar to auto but without the safety classifier. Use this only for tasks in sandboxed environments where there is no risk of damage.

bypassPermissions

No restrictions whatsoever. Only use this in fully isolated, disposable environments like throwaway containers or CI runners where nothing valuable can be affected.

The progression for most developers is: start with default, move to acceptEdits after a few days, use plan for architecture work, and use auto for well-defined tasks in trusted environments.

Extended Thinking

For complex problems -- intricate bugs, architectural decisions, performance optimization -- you can enable extended thinking, which gives Claude more time and token budget to reason before responding:

Alt+T (Windows/Linux)
Option+T (macOS)

This toggles extended thinking on and off during your session. When enabled, Claude uses a chain-of-thought process that produces longer, more thorough reasoning. The tradeoff is that responses take longer and consume more tokens.

Use extended thinking when:

  • Debugging a subtle race condition or concurrency issue
  • Designing a complex data model with many relationships
  • Reviewing security-critical code where missing a vulnerability matters
  • Optimizing a hot path where you need to consider multiple approaches

Do not use extended thinking for routine tasks like formatting code, writing simple functions, or generating boilerplate. The extra reasoning time adds no value for straightforward work.

Effort Levels

Complementary to extended thinking, the /effort command controls how deeply Claude engages with each request:

/effort low      # Quick, concise responses — good for simple questions
/effort medium   # Balanced depth (default)
/effort high     # Thorough analysis and implementation
/effort max      # Maximum depth — explores every edge case
/effort auto     # Claude decides based on the complexity of each request

Use /effort low when you are asking quick questions or need short answers. Use /effort high when you are tackling a complex bug or designing a critical system. The auto setting lets Claude calibrate its own effort based on the apparent complexity of your request.

Try this: set /effort low and ask a simple question, then set /effort high and ask about a complex bug. Compare the depth and detail of each response.

Context Management

Claude Code's context window is finite. As your session grows, older context gets pushed out. Active context management keeps your session productive over long periods.

Compact your context when the window starts filling up:

/compact

This summarizes the conversation so far into a condensed form, freeing up context space while retaining the key decisions, code state, and task progress. Think of it as compressing your session's memory.

You can also provide a focus hint:

/compact Focus on the authentication refactor — discard details about the UI changes.

Visualize context usage to understand what is consuming your window:

/context

This shows a breakdown of what is using your context: conversation history, file contents, tool outputs, and system prompts. If you see that a large file read is dominating, you know to compact or focus your queries.

Channels: Multi-Session Workflows

For large projects that span multiple workstreams, channels provide structured multi-session workflows:

/channel create auth-refactor
/channel create api-v2
/channel switch auth-refactor

Each channel maintains its own conversation history and context. You can switch between channels to work on different aspects of a project without contaminating the context of unrelated work.

Channels are especially useful for:

  • Working on multiple features simultaneously
  • Keeping bug-fix sessions separate from feature development
  • Maintaining a long-running architecture discussion alongside daily coding

Voice Dictation

For brainstorming sessions, code reviews, or when you want to think out loud, Claude Code supports voice input:

Toggle voice dictation to speak your prompts instead of typing them. This is particularly useful for:

  • Brainstorming architectural ideas while away from the keyboard
  • Describing bugs you are seeing in a running application
  • Reviewing code hands-free while reading on a second monitor

Combining Advanced Features

The real power comes from combining these workflows. Here is a pattern for tackling a major feature:

1. /plan — Design the feature (read-only exploration)
2. Review and refine the plan
3. /effort high — Set high effort for implementation
4. --permission-mode acceptEdits — Trust file edits, review commands
5. Implement module by module, using /compact between major sections
6. /effort low — Switch to low effort for quick test runs
7. If stuck on a bug → Alt+T for extended thinking
8. /checkpoint to save state before risky integration step
9. Final review with /diff

Another pattern for complex debugging:

1. --permission-mode plan — Start in read-only to understand the issue
2. Alt+T — Enable extended thinking for deeper analysis
3. /effort max — Maximum analytical depth
4. Once root cause is identified → switch to acceptEdits mode
5. /effort medium — Standard effort for the fix
6. Implement fix, run tests, verify

Tips for Power Users

Match permission mode to the task. Do not stay in default mode forever. Once you trust Claude's editing, move to acceptEdits. For autonomous tasks, use auto. The right mode reduces friction without sacrificing safety.

Use /plan for anything that touches more than three files. The upfront investment in planning saves you from rework. Plans also serve as documentation of your architectural decisions.

Compact proactively. Do not wait until you hit context limits. After completing a major subtask, run /compact to free up space for the next phase.

Set effort level intentionally. Most developers leave it at medium forever. Adjusting effort per task gives you faster responses for simple work and deeper analysis when you need it.

Combine extended thinking with specific questions. "Why is this test flaky?" with extended thinking produces much better results than a vague "help me debug this."

These advanced workflows transform Claude Code from a code-generation tool into a full development partner that adapts to the complexity and requirements of each task.