Claude Code Four-Step Workflow: A Practical Guide to Explore → Plan → Code → Commit

Why You Need a Structured Coding Workflow

Most people jump straight into asking Claude Code to write code. While this seems efficient, it actually leads to extensive debugging and rework down the line. The truly efficient approach follows a four-step workflow: Explore → Plan → Code → Commit.

The core philosophy of this workflow is: do thorough preparation before writing code, shifting error correction to the planning phase rather than discovering you've gone in the wrong direction after the code is already written.

This four-step workflow essentially borrows from the classic "Shift Left" philosophy in software engineering—moving quality assurance activities as early as possible in the development lifecycle. Research shows that defects found during the requirements and design phases cost only 1/10 to 1/100 as much to fix compared to those found during the coding phase. When we apply this philosophy to AI-assisted programming, it means ensuring the direction is correct before the LLM generates code is far more economical than making corrections afterward. This also aligns with the Chain-of-Thought principle in prompt engineering: having AI reason before acting significantly improves output quality.

Explore + Plan: Laying the Groundwork with Planning Mode

Entering Plan Mode

The fastest way to handle the first two steps is to use Plan Mode. In planning mode, Claude cannot edit files—it can only read files to gather information and research how to implement your requirements.

Plan Mode essentially constrains Claude Code's tool-calling permissions. In normal mode, Claude Code has multiple tool permissions including file read/write and terminal command execution; in Plan Mode, the system retains only file reading and search tools while disabling all write operations. This design leverages an important cognitive principle: when AI is restricted to observing without acting, it allocates more "computational resources" to analysis and reasoning rather than rushing to produce code. This is similar to how humans often make more comprehensive assessments when constrained to "look but don't touch."

The operation is simple: press Shift + Tab until the Plan Mode indicator appears below the text input box.

How to Write a Good Planning Request

A good planning request should clearly tell Claude what information you need. For example:

"I need to add WebP conversion to the image upload pipeline. Please figure out where in the pipeline it should happen, whether new dependencies are needed, and how to implement it."

Claude will read relevant files, perform web searches, and then provide an action plan.

Why the Planning Phase Is the Best Time for Course Correction

This is the most critical point in the entire workflow: the planning phase is the optimal time to correct direction because no code has been written yet.

Once you receive the plan, you need to carefully review whether it meets your standards. If you're not satisfied, you can ask Claude to supplement or modify certain parts. This is far more efficient than tearing everything down after the code is already written.

Exploring Without Entering Plan Mode

It's worth noting that you don't necessarily need to enter Plan Mode to explore. You can directly ask Claude to explore your codebase—for example, asking about a module's architecture or a function's call chain.

Code: Best Practices for the Coding Phase

Approving the Plan and Starting Execution

Once the plan looks good, select Approve to accept it and let Claude work through the checklist item by item. You can choose to have Claude auto-accept file edits or ask you each time.

Claude will do its best to troubleshoot code issues on its own before considering the plan complete, but sometimes you'll still need to intervene with corrections. This is precisely the benefit of planning mode—after the plan is complete, you share the context of the entire reasoning process, which helps guide Claude's next decisions.

Making "Correct" Criteria Explicit for Claude

For Claude to be confident about results, it must know what counts as "correct." When writing your plan, make acceptance criteria as explicit as possible.

Clear acceptance criteria matter because of how LLMs fundamentally work. Large language models are essentially doing "next token prediction" and need clear goal signals to guide generation direction. Vague instructions cause the model to "hesitate" between multiple possible implementations, potentially choosing one that seems reasonable but doesn't match the developer's intent. Specific acceptance criteria (such as "the function should return results within 100ms" or "support both PNG and JPEG input formats") provide explicit constraints for the model, dramatically narrowing the solution space and making output more predictable and controllable.

Adding Auxiliary Tools to Reduce Back-and-Forth

Giving Claude tools that help it achieve its goals can dramatically reduce the number of back-and-forth exchanges:

• Web UI Development: Install the Claude in Chrome extension, allowing Claude Code to control browser tabs and self-test UI results before considering the task complete
• Test Suites: Include a test suite in your project so Claude can continuously validate code. Ensure the test suite is a trusted source of truth for you and your team to avoid false positives

Handling Recurring Issues

A practical tip: if you notice Claude repeatedly encountering the same issues, have it save the solutions to a CLAUDE.md file. This way, next time it encounters a similar problem, Claude can directly reference the previous solution.

CLAUDE.md is a project-level configuration file specific to Claude Code that is automatically loaded into Claude's context window at the start of each session. This mechanism addresses a fundamental limitation of LLMs—the lack of persistent memory across sessions. By writing project conventions, common pitfalls, and architectural decisions into CLAUDE.md, developers are essentially building an "external memory system." This is similar in concept to RAG (Retrieval-Augmented Generation) but more lightweight and controllable. CLAUDE.md supports a hierarchical structure: you can place files in the project root, subdirectories, or even the user's home directory, and Claude will merge these configurations by priority.

Commit: Review and Submit

Running Code Review Before Committing

Once you've tested everything yourself and are satisfied with the results, don't rush to commit. A good practice is: run a sub-agent code reviewer to check your code before committing. This adds an extra quality gate.

A sub-agent refers to an independent reasoning instance launched within the main Claude Code session. It has its own context window and is not affected by the "anchoring effect" of the main session's existing conversation history. This is crucial: because the Claude in the main session has already "participated" in writing the code, it has confirmation bias and tends to believe its own code is correct. A sub-agent reviews the code from a fresh perspective, making it easier to spot logical gaps, missed edge cases, or style inconsistencies. This essentially simulates the human team best practice of "code review should be performed by someone other than the author."

Generating Style-Consistent Commit Messages

After the review passes, have Claude generate a commit message in your preferred style. This ensures commit message quality while saving you time.

Then, rinse and repeat—start developing the next feature.

Four-Step Workflow Summary

Step	Core Purpose
Explore	Provide Claude with relevant project context
Plan	Create an action plan that serves as success criteria
Code	You and Claude collaborate iteratively until plan goals are met
Commit	Review and push code, prepare to start the next feature

The essence of this workflow is: front-load the thinking, minimize the cost of corrections. Rather than having Claude blindly write code and then repeatedly revise it, invest time upfront to help it understand the project and formulate a plan, then execute efficiently. This applies not only to Claude Code but is a universal best practice for all AI-assisted programming.