Plan Mode & Development Workflows

Claude Code comes with a handful of development workflows baked right in. This lesson goes deep on Plan Mode, then covers proven patterns for TDD, debugging and git.

I grew up working construction with my dad, and his whole deal was simple... do it right or don't bother doing it at all. Plan Mode is that same idea, just for code.

Plan Mode Deep Dive#

Toggle. Press Shift+Tab to cycle through the permission modes until the status bar says plan mode is on, and keep pressing to leave it. You can also type /plan in front of a single prompt to jump straight in.

In Plan Mode, Claude does four things.

• Explores your codebase (reads files, searches patterns)
• Designs an approach
• Presents the plan for your approval
• Waits for your go-ahead before implementing anything

When to use Plan Mode.

• Complex features that touch multiple files
• Refactoring with lots of changes that depend on each other
• When you want to review the approach before any code changes
• Architecture decisions where the wrong call is expensive to undo

When NOT to use Plan Mode.

• Simple one-file edits
• Quick bug fixes where the answer is obvious
• Adding a single function with clear requirements

The Plan-Implement-Verify Workflow#

This is the workflow to use for anything that isn't trivial.

Step 1. Plan (in Plan Mode)#

Describe your goal. Let Claude poke around and propose an approach. Review the plan, ask questions and tighten it up.

Step 2. Approve & Implement#

When the plan is ready, Claude asks how you want to proceed. Pick one of the "Yes" options (auto mode, or approving each edit yourself) and Claude leaves Plan Mode and builds out the plan. Pick "No, keep planning" to send it back with notes.

Step 3. Verify#

Claude runs tests, builds or other checks. Look over the output, and if something's off, tell it.

This workflow heads off the most common failure out there... Claude building the WRONG thing and then having to rip everything back out.

TDD with Claude Code#

Test-Driven Development works really well with Claude.

Step 1. Write Tests First#

Describe the behavior you want as tests. Give Claude the test file and the expected assertions.

Step 2. Implement to Pass#

Tell Claude "Make these tests pass. Don't modify the test file." Now it has a crystal clear target.

Step 3. Refactor#

Once the tests pass, ask Claude to clean up the implementation while keeping the tests green.

Why TDD works well with Claude.

• Tests are unambiguous requirements, so there's no room for guessing
• Claude can run the tests itself to check its own work
• The red-green-refactor cycle keeps changes small and easy to check

Debugging Workflow#

When you're hunting down a bug, go in this order.

Step 1. Reproduce#

Give Claude the exact steps, the error message and the conditions. "This TypeError happens when clicking Submit on the checkout page with an empty cart."

Step 2. Isolate#

Ask Claude to find where the error starts, and hand it the stack trace if you've got one. "Find where this null reference occurs in the checkout flow."

Step 3. Fix#

Once it's pinned down, ask Claude to fix it. Throw in a constraint like "Fix this without changing the public API."

Step 4. Verify#

"Run the tests" or "Build the project" to make sure the fix didn't break something else.

Git Integration#

Claude Code has full git integration. Here are the moves you'll use most.

Creating Commits#

"Commit these changes with a descriptive message"

Claude stages the relevant files, writes a commit message based on what changed, and creates the commit.

Creating Branches#

"Create a feature branch for this work called feature/add-search"

Creating Pull Requests#

"Create a PR for this branch with a summary of the changes"

Claude uses the gh CLI to create PRs with proper titles, descriptions and linked issues.

Reviewing Diffs#

"Show me what changed since the last commit"
"Review the diff and check for issues"

Combining Workflows#

Real work usually mixes a few of these patterns together.

1. Plan Mode: "I need to add a search feature. Plan the approach."
2. Review plan, provide feedback
3. Approve the plan: Claude implements
4. "Write tests for the search feature"
5. "Run the tests and fix any failures"
6. "Commit these changes"
7. "Create a PR"

That's a full feature delivery cycle, from idea to a PR somebody can review. Measure twice, cut once (dad would be proud).

TL;DR#

• Shift+Tab (or /plan) gets you into Plan Mode so you can explore before acting
• Plan → Implement → Verify keeps you from wasting effort
• TDD gives Claude a clear target ("make these tests pass")
• Debugging goes Reproduce → Isolate → Fix → Verify
• Git stuff (commit, branch, PR) works right through Claude
• Mix and match workflows to ship complete features