🤖 Plan and Loop Modes

A mode that lets Claude think and propose a plan before taking any action.

Prevents costly errors and rework by planning first.

Use Shift+Tab to activate; plan visible before execution.

Criteria for deciding whether plan mode is worthwhile or direct execution is faster.

Not every task needs a plan; using one unnecessarily wastes tokens.

Complexity, risk, number of affected files.

The components of a good plan: goal, steps, dependencies, risks.

Knowing how to read a plan lets you evaluate whether it will work before approving it.

Steps, file list, risk assessment, order of operations.

The approval flow where you review the plan and can adjust it before running it.

It's the control point: you decide whether to run, modify, or reject.

Approve, reject, refine; a feedback loop before the action.

Technique of requesting multiple adjustments to the plan until it’s ideal.

A refined plan saves hours of rework later.

Multi-turn planning; plan as a living draft.

Common mistakes: approving without reading, overplanning, ignoring the plan and executing directly.

Recognizing anti-patterns keeps you on a productive path.

Over-planning; rubber-stamp approval; plan drift.

Plan structure for implementing a completely new feature.

New features are where plan mode shines most: it prevents bad architecture.

Scoping; interface first; test plan.

How to plan a safe refactor with test coverage and rollback.

Refactors without a plan become snowballs; with a plan, they’re surgical.

Strangler pattern; test-first refactor; incremental steps.

A plan to diagnose the root cause, fix it, and validate without regressions.

Rushed bug fixes create new bugs; the plan disciplines the workflow.

Reproduce first; root cause; regression test.

Technique of breaking a large task into atomic, independent steps.

Atomic tasks are easier to verify and revert.

Atomic steps; single responsibility; verifiable output.

Identify which steps depend on others to determine the right order.

Wrong dependencies = wasted work and conflicts.

Task DAG; critical path; blockers.

How to estimate the tokens, time, and iterations a plan will take.

Allows you to decide whether it's worth running or whether it's better to simplify the plan.

Token budget; iteration count; complexity heuristics.

A mode that lets Claude execute, verify the result, and iterate automatically.

Automates the edit-test-fix cycle that takes hours in manual mode.

--dangerously-skip-permissions; auto-accept; iteration limit.

Criteria for loop mode vs. normal interactive mode with approval at each step.

Loop mode without criteria can burn tokens or make unwanted changes.

Trust in the outcome; reversibility; supervision cost.

Mechanisms to prevent the loop from causing damage: allowedTools, max turns, git worktree.

Security is what lets you trust the loop and step out for coffee.

allowedTools; permission scopes; worktree isolation.

Tools for observing what the loop is doing: logs, diff, test output.

Monitoring lets you intervene before problems pile up.

Terminal watch; git diff --stat; CI status.

Stop criteria: tests passing, linter clean, stable diff.

Infinite loop = burned tokens; clear criteria = efficiency.

Exit conditions; convergence; diminishing returns.

Differences between local loop mode and background agents (GitHub Actions, etc.).

Each approach has trade-offs in cost, speed, and control.

Local vs. remote; latency; cost per iteration.

Run tests, fix failures, rerun until everything passes.

The most common and useful loop mode pattern.

pytest/jest loop; error parsing; auto-fix.

Run the linter, fix warnings, rerun until there are zero errors.

Clean up lint across an entire codebase in minutes, not hours.

eslint --fix; black/ruff; iterative cleanup.

Migrate APIs, dependencies, or versions file by file with validation.

Migrations are tedious for humans, perfect for loops.

File-by-file; type-check gate; incremental commit.

Process, transform, and validate datasets iteratively.

Dirty data needs multiple passes; a loop does that without you.

Schema validation; data cleaning passes; assertion gates.

Generate docs, validate links, update examples until everything is consistent.

Outdated docs kill projects; the loop keeps them in sync.

Docstring sync; link checker; example runner.

Combine exit criteria: tests + lint + types + build all green.

The compound loop is the closest thing to CI/CD running locally.

Multi-gate loop; combined exit criteria; script orchestration.

The ideal workflow: plan mode first, loop mode to execute, human review at the end.

It's the gold standard for complex tasks with Claude Code.

Three-phase pipeline; handoff points; review gate.

How to transition from the approved plan to the loop without losing context.

A poorly handled handoff can make the loop skip parts of the plan.

Context preservation; explicit instructions; checkpoint.

Strategies for using plan+loop in projects with dozens of files.

Large projects require decomposition; without it, the loop loses its way.

Phased execution; module boundaries; progressive disclosure.

Coordinate changes across multiple files while maintaining consistency.

Most features touch several files; orchestration is essential.

Cross-file consistency; import graphs; batch edits.

How to undo the loop's work when something goes wrong: git, worktrees, stash.

The ability to roll back safely is what lets you take more risks in the loop.

git reset; worktree discard; incremental commits.

Real examples of plan+loop pipelines in production projects.

Seeing concrete cases solidifies your understanding of the workflow.

Real-world patterns; lessons learned; metrics.

The paradigm shift: from an assistant that responds to an agent that acts.

Understand the philosophy and what enables you to use the modes fluently.

Agentic vs. assistive; autonomy spectrum; intent-driven.

How to delegate tasks to the agent without micromanaging or abandoning it.

Delegation is the human skill that scales the most with agentic AI.

Clear intent; success criteria; scope boundaries.

The difference between reviewing the result and controlling every step.

Micromanagement kills productivity; review ensures quality.

Output review; trust but verify; spot checks.

How to adjust your level of trust in the agent as you gain experience.

Too much trust = bugs; too little trust = slowness.

Progressive trust; track record; domain-specific confidence.

How to measure whether you're actually more productive with agentic coding.

Without metrics, you don’t know whether you’re making progress or just spending tokens.

Tasks/day; time-to-merge; rework rate; cost per task.

The mindset shift from "I code" to "I direct and review."

The biggest obstacle isn't technical; it's mental. Those who change their mindset take off.

Director mindset; let go of typing; focus on outcomes.