Skip to main content

Effective Workflows with Claude Code

Claude Code is unopinionated, allowing you to adapt it to many workflows. This guide covers proven patterns that maximize productivity and code quality.

Core Workflow: Explore → Plan → Code → Commit​

This four-phase approach works for most development tasks:

1. Explore​

Start by understanding the codebase:

Read the files related to user authentication
Show me how the logging system works
tip

Explicitly tell Claude not to write code during exploration:

Read logging.py and explain how it works. Don't make any changes yet.

2. Plan​

Ask Claude to think through the problem:

Think about how to add OAuth2 authentication to this app. Create a detailed plan.

For complex problems, use more intensive thinking:

  • think - Standard analysis
  • think hard - Deeper analysis
  • think harder - More computational budget
  • ultrathink - Maximum depth

3. Code​

Approve the plan and implement:

Great plan. Please implement the OAuth2 authentication as discussed.

Encourage verification:

Implement the changes and verify your work step by step

4. Commit​

Complete the workflow with version control:

Commit these changes with a descriptive message
Create a pull request for the OAuth2 feature

Test-Driven Development (TDD)​

TDD with Claude ensures quality and clarity:

Step 1: Write Tests First​

Write tests for a new EmailValidator class that should:
- Validate email format
- Check for disposable email domains
- Ensure email length is reasonable
Remember, we're doing TDD so don't implement the class yet

Step 2: Run Tests (Expect Failure)​

Run the tests and confirm they fail

Step 3: Implement​

Now implement the EmailValidator class to make all tests pass.
Don't modify the tests.

Step 4: Iterate​

Run the tests again. If any fail, fix the implementation.

Step 5: Commit​

Great! All tests pass. Commit both the tests and implementation.

Visual Development: Mock → Build → Iterate​

Perfect for UI work:

Step 1: Provide Visual Target​

Here's a mockup of the dashboard we need to build: [drag and drop image]

Step 2: Implementation​

Implement this dashboard design using our existing component library

Step 3: Screenshot & Compare​

Take a screenshot of the implemented dashboard

Step 4: Iterate​

The spacing looks off. Make the cards more compact and add shadows like in the mockup

Multi-File Refactoring​

For large-scale changes:

Step 1: Analysis​

Analyze all files using the old Logger class and list them

Step 2: Plan​

Create a plan to migrate from Logger to the new StructuredLogger across all files

Step 3: Execute with Tracking​

Create a checklist of files to migrate, then work through them one by one

Step 4: Verification​

Run all tests to ensure the migration didn't break anything

Git Workflows​

Feature Branch Workflow​

1. Create a new feature branch for the user dashboard
2. Implement the dashboard components
3. Commit with conventional commit messages
4. Push the branch and create a pull request

Fixing CI Failures​

The CI build is failing. Check the error logs and fix the issues.
Review the PR comments from the team and address each concern

Codebase Q&A and Onboarding​

Great for learning new codebases:

Architecture Understanding​

How does the authentication flow work in this application?
What's the relationship between the User and Account models?

Best Practices Discovery​

What patterns does this codebase use for error handling?

Cross-Language Learning​

Show me the Python equivalent of the validation in validator.js

Safe YOLO Mode​

For rapid development in sandboxed environments:

claude --dangerously-skip-permissions

Use cases:

  • Fixing hundreds of lint errors
  • Generating boilerplate code
  • Running in Docker containers
caution

Only use in disposable environments or with proper backups!

Collaborative Workflows​

Plan Mode for Code Reviews​

Enable Plan Mode (Shift+Tab) during reviews:

Review this pull request and suggest improvements

Pair Programming​

Let's work through this algorithm together. First, explain your approach for solving the traveling salesman problem.

Performance Optimization​

Step 1: Profile​

Run the performance profiler and identify bottlenecks

Step 2: Analyze​

Look at the hottest code paths and suggest optimizations

Step 3: Implement​

Implement the memoization optimization for the fibonacci function

Step 4: Verify​

Run the profiler again and compare the results

Project Templates​

Get claude-setup Framework

The claude-setup framework includes pre-built workflows for:

  • Project scaffolding
  • Git workflow automation
  • Testing pipelines
  • Deployment procedures

Best Practices​

1. Clear Task Boundaries​

Bad:

Fix the app

Good:

Fix the TypeError in UserProfile component when user.email is undefined

2. Incremental Progress​

Break large tasks into smaller chunks:

Let's refactor the authentication system:
1. First, list all files that import the Auth module
2. Create the new AuthV2 module with the same interface
3. Migrate one file at a time

3. Context Management​

Use /clear between unrelated tasks:

/clear
Now let's work on the payment integration

4. Verification Steps​

Always verify critical changes:

Show me the diff of what you changed
Run the test suite
Check that the app still builds

Next Steps​