Welcome back to Advanced Claude Code Features! In the previous lessons, we explored custom slash commands and learned how to manage tool permissions. Now, we will discover two powerful features that give us greater control over how Claude plans and executes complex operations.

In this lesson, we will explore Plan Mode and Task delegation. Plan Mode allows us to review Claude's proposed approach before execution, while Task delegation enables us to offload verbose work to subagents in separate contexts. These features are particularly valuable when we need careful oversight or want to avoid flooding our conversation with extensive output.

By the end of this lesson, we will understand when and how to use these advanced workflow controls, giving us confidence to handle risky operations and large-scale analysis tasks efficiently.

When we work with Claude Code, some operations carry significant consequences: renaming database fields across dozens of files, refactoring API endpoints, or analyzing entire codebases with hundreds of files. These scenarios present two distinct challenges.

The first challenge is risk management. Large-scale refactoring can affect many files simultaneously. If something goes wrong, the impact multiplies. We need a way to review the plan before execution begins.

The second challenge is context management. When analyzing 200 files or generating comprehensive documentation, the output can fill our conversation context, making it harder to focus on other work. We need a way to delegate these tasks while keeping our main conversation clean.

Claude Code addresses both challenges: Plan Mode for reviewing before execution, and Task delegation for managing verbose or independent work.

Plan Mode is a structured workflow where Claude creates a detailed written plan before executing any tools. The workflow involves three phases:

1. Exploration - Claude uses tools to understand the codebase scope
2. Interview - Interactive menu gathers your preferences
3. Plan Creation - Detailed approach documented in a markdown file

Let's see this in action with a function renaming scenario:

❯ rename the calculateTotal function to getTotal

● I'll help you rename the calculateTotal function. Let me explore the 
  codebase to find where it's defined and used.

● Explore(Find calculateTotal function) Haiku 4.5
  ⎿ Done (9 tool uses · 12.9k tokens · 27s)

Claude explores with a subagent to understand the structure without cluttering our conversation. Then it presents an interactive interview:

───────────────────────────────────────────────────────────────
 ☐ New name

Which name would you like to use for the renamed function?

❯ 1. getTotal
     More specific to calculating totals/prices.
  2. computeSum
     More generic, emphasizes computation.
  3. Other
───────────────────────────────────────────────────────────────
Enter to select · ↑/↓ to navigate · Esc to cancel

After we answer, Claude creates a comprehensive written plan:

● User answered Claude's questions:
  ⎿ · Which name would you like to use? → getTotal

● Updated plan
  ⎿ Wrote 45 lines to ~/.claude/plans/clever-floating-puddle.md
     # Plan: Rename calculateTotal to getTotal
     ## Overview
     Rename the `calculateTotal` function to `getTotal` across the codebase.
     ## Implementation Steps
     1. Update Function Definition (utils/calculator.js:1-3)
     2. Update Export Statement (utils/calculator.js:6)
     3. Update Import in invoiceService.js
     4. Update Function Call in invoiceService.js
     [... full plan details ...]

We can now review the full plan before proceeding:

───────────────────────────────────────────────────────────────
 Ready to code?

 ❯ 1. Yes, clear context and auto-accept edits (shift+tab)
   2. Yes, auto-accept edits
   3. Yes, manually approve edits
   4. Type here to tell Claude what to change

 ctrl-g to edit in Vim · ~/.claude/plans/clever-floating-puddle.md

When we approve, Claude executes the plan step-by-step with verification:

● Update(utils/calculator.js)
  ⎿ Added 1 line, removed 1 line
      1 -function calculateTotal(items) {
      1 +function getTotal(items) {

● Verification
● Search(pattern: "calculateTotal")
  ⎿ Found 0 files

● Implementation Complete
  ✅ All files have valid syntax
  ✅ No remaining references to calculateTotal found

Plan Mode automatically activates for operations with significant scope:

● Plan Mode triggers automatically for:
  ✓ Large-scale refactoring (renaming across many files)
  ✓ Database schema changes
  ✓ API endpoint modifications affecting multiple services
  ✓ Complex multi-step operations

  You can also explicitly request:
  - "Create a plan to..." - Triggers interview and planning
  - "/plan" - Activates Plan Mode for next operation
  - "Implement the following plan:" - Executes a saved plan

  Toggle execution modes: Shift+Tab cycles through
  Normal → ⏵⏵ Auto-Accept → Manual Approval

Task delegation addresses operations producing extensive output. A Task is a separate execution context where a subagent performs independent work without cluttering our main conversation.

To use Task delegation, explicitly request it in your prompt:

❯ Create a task to analyze this large codebase — it has 200+ files

● Task(analyze_codebase)
  Delegating to background task...
  
  [Task running in separate context]

● Task completed! Summary:
  
  Architecture:
  - Frontend: React (80 components)
  - Backend: Express (25 routes)
  - Database: PostgreSQL (15 tables)
  
  Key findings:
  - 3 unused dependencies
  - 12 files without tests
  
  Full details saved to: codebase_analysis.md

The summary provides essential insights without overwhelming our conversation, while the full analysis is preserved for deeper investigation.

Important: Without explicitly requesting a Task, verbose operations may output directly to your main conversation. Use phrases like "create a task to..." or "delegate to a task..." to ensure clean context management.

Use Plan Mode when:

• Large-scale refactoring operations
• Database schema changes
• Multi-step coordinated changes
• Any operation where you want to review the approach before execution

Use Task delegation when:

• Operations produce verbose output (analyzing 200+ files)
• Task is independent and doesn't need conversation history
• You need to keep your main context clean for other work

Trigger Task delegation explicitly with phrases like:

• "Create a task to analyze entire codebase"
• "Delegate generating documentation for all APIs to a task"
• "Use a task to find all TODO comments"

Don't use Tasks for:

• Quick file reads (just use Read)
• Operations needing your conversation context
• Tasks requiring back-and-forth interaction

For sophisticated workflows, additional commands are available:

/plan   - Explicitly trigger Plan Mode for next operation
/agents - List all subagents (built-in + custom)
/tasks  - View active background tasks

You can also start Claude with Plan Mode enabled from the beginning:

claude --permission-mode plan

This ensures all operations begin with the planning workflow.

For everyday work, remember:

• Shift+Tab = Cycle execution modes
• "Create a plan to..." = Triggers planning workflow
• "Create a task to..." = Delegates to separate context

In this lesson, we learned two powerful workflow control features. Plan Mode provides structured planning through exploration, interview, and written documentation before execution—invaluable for risky operations. Task delegation offloads verbose work to subagents in separate contexts, keeping our conversation clean during extensive analysis.

These features transform how we handle complex operations: Plan Mode gives confidence through structured review, while Task delegation prevents context overload when explicitly requested. Now, it's time to practice! The upcoming exercises will challenge you to apply these concepts in realistic scenarios. Get ready to master advanced Claude Code workflows!