AI CODING TOOLS / LESSON 08

Plan Mode & Development Workflows.

Master the plan-implement-verify workflow

Written by Andrew Lee JenkinsPublished Oct 5, 202614 min readFree lesson

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

Example

"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

Example

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

Creating Pull Requests

Example

"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

Example

"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.

Example

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

Loading the lesson…

Loading activities…