prompting

>Use Plan Mode for Complex Tasks

planningarchitecturebest-practices
Source:▶Claude Code Masterclass: From Beginner to Expert|@CS Dojo

When you're working with Claude on complex coding tasks, your natural instinct might be to jump straight into implementation. After all, AI is powerful, right? It should be able to handle anything you throw at it. But here's the reality: even the most advanced AI benefits from a structured approach. Using plan mode—asking Claude to create a detailed plan before writing any code—can double your success rate on complex features.

Think of it like building a house. You wouldn't tell a contractor "build me a house" and expect perfect results without blueprints. The same principle applies to AI coding. When you ask Claude to plan first, you're creating those blueprints together.

Why Plan Mode Works So Well

Complex tasks involve multiple moving parts, architectural decisions, and potential edge cases. When you ask Claude to jump straight into code, it has to make all these decisions on the fly while simultaneously writing implementation details. That's a recipe for missed requirements, architectural inconsistencies, and code that works but isn't maintainable.

Plan mode separates the "what" from the "how." First, you align on the overall approach, file structure, and key decisions. Then, you implement with confidence, knowing the foundation is solid.

Step 1: Start with a Planning Prompt

Your planning prompt should be specific about what you want to build, but avoid implementation details. Here's how to structure it:

Plan how we should implement [feature/system] that [specific requirements].

Include:
- Overall architecture approach
- Files we'll need to create/modify  
- Key technologies or patterns to use
- Potential challenges or edge cases
- Step-by-step implementation order

For example, instead of asking "Help me build user authentication," try this:

Plan how we should implement user authentication with OAuth that supports:
- Google and GitHub login
- JWT token management
- Protected routes in a React app
- User profile storage in PostgreSQL

Include the overall architecture approach, files we'll need to create, 
key libraries to use, and the step-by-step implementation order.

This gives Claude clear boundaries and expectations for the planning phase.

Step 2: Review and Refine the Plan

Claude will respond with a structured plan that typically includes:

  • Architecture overview
  • File structure and responsibilities
  • Technology recommendations
  • Implementation steps in order
  • Potential gotchas or considerations

Here's what a typical plan response looks like:

## OAuth Authentication Implementation Plan

### Architecture Overview
- Frontend: React with Context API for auth state
- Backend: Express.js with Passport.js for OAuth
- Database: PostgreSQL with user profiles table
- JWT tokens for session management

### File Structure

src/ ├── components/ │ ├── LoginButton.jsx │ └── ProtectedRoute.jsx ├── contexts/ │ └── AuthContext.jsx ├── services/ │ └── authService.js └── server/ ├── routes/auth.js ├── middleware/authMiddleware.js └── models/User.js


### Implementation Steps
1. Set up OAuth applications (Google, GitHub)
2. Configure Passport.js strategies
3. Create user model and database migrations
4. Build authentication routes
5. Implement JWT token handling
6. Create React auth context
7. Build login/logout components
8. Add route protection

Don't just accept this plan blindly. This is your chance to catch issues early:

  • Does the file structure make sense for your project?
  • Are the technology choices appropriate?
  • Are there missing requirements or edge cases?
  • Does the implementation order seem logical?

Ask follow-up questions or request modifications:

This plan looks good, but I'm using Next.js instead of plain React. 
Can you adjust the plan to use Next.js API routes and middleware 
instead of a separate Express server?

Step 3: Implement Step by Step

Once you're aligned on the plan, implement it piece by piece. Reference the plan in your implementation prompts:

Based on our plan, let's start with step 1: setting up the Passport.js 
OAuth strategies for Google and GitHub. Create the configuration code 
and show me how to structure the strategy files.

This approach keeps Claude focused and ensures consistency across implementation steps. Each piece of code will align with the overall architecture you agreed on.

Step 4: Handle Changes Gracefully

Complex projects evolve. When you need to deviate from the original plan, update it explicitly:

I need to modify our plan. Instead of storing user profiles directly 
in PostgreSQL, I want to use a Redis cache for session data and only 
store essential user info in the database. How should we adjust our 
implementation approach?

Claude will help you think through the implications and update the relevant parts of your plan.

Pro Tips for Effective Planning

Be specific about your constraints. If you're working with a legacy codebase, specific framework versions, or deployment requirements, mention them upfront:

Plan how to add real-time notifications to our Django 2.2 app that 
currently uses PostgreSQL and is deployed on Heroku. We can't use 
WebSockets due to infrastructure limitations.

Ask for alternatives. Complex problems often have multiple valid solutions:

Plan two different approaches for implementing file uploads: 
one using cloud storage (S3) and another using local storage. 
Include pros/cons of each approach for a small team.

Include non-functional requirements. Security, performance, and maintainability matter:

Plan a caching strategy that can handle 10,000+ concurrent users 
while keeping data fresh and maintaining security for user-specific content.

Common Planning Pitfalls

Don't make plans too detailed. You want a roadmap, not a step-by-step tutorial. If Claude starts writing actual code in the planning phase, redirect it:

This is getting too detailed. I just need the high-level approach 
and file structure for now. We'll implement the specifics step by step.

Don't skip the review phase. It's tempting to take Claude's first plan and run with it, but spending 5 minutes reviewing and asking clarifying questions can save hours of refactoring later.

Don't treat plans as immutable. Software development is iterative. Be ready to adjust the plan as you learn more about the problem space.

What's Next

Once you've mastered basic planning, explore related techniques that build on this foundation. Learn about iterative refinement—how to use Claude's feedback to improve your code step by step. Dive into architectural reviews, where you can ask Claude to analyze existing codebases and suggest improvements. And consider prompt templates that help you consistently structure complex requests for better results.

The key insight is that AI coding isn't about finding the perfect one-shot prompt. It's about building a collaborative workflow where you and Claude work together systematically to solve complex problems. Plan mode is your foundation for that collaboration.

←cd ~/tips