Tutorials

This guide provides step-by-step tutorials for common workflows with Claude Code. Each tutorial includes clear instructions, example commands, and best practices to help you get the most from Claude Code.

​

Table of contents

• Resume previous conversations
• Understand new codebases
• Fix bugs efficiently
• Refactor code
• Work with tests
• Create pull requests
• Handle documentation
• Work with images
• Use extended thinking
• Set up project memory
• Set up Model Context Protocol (MCP)
• Use Claude as a unix-style utility
• Create custom slash commands
• Run parallel Claude Code sessions with Git worktrees

​

Resume previous conversations

​

Continue your work seamlessly

When to use: You’ve been working on a task with Claude Code and need to continue where you left off in a later session.

Claude Code provides two options for resuming previous conversations:

• --continue to automatically continue the most recent conversation
• --resume to display a conversation picker

claude --continue

claude --continue --print "Continue with my task"

claude --resume

How it works:

1. Conversation Storage: All conversations are automatically saved locally with their full message history
2. Message Deserialization: When resuming, the entire message history is restored to maintain context
3. Tool State: Tool usage and results from the previous conversation are preserved
4. Context Restoration: The conversation resumes with all previous context intact

Tips:

• Conversation history is stored locally on your machine
• Use --continue for quick access to your most recent conversation
• Use --resume when you need to select a specific past conversation
• When resuming, you’ll see the entire conversation history before continuing
• The resumed conversation starts with the same model and configuration as the original

Examples:

# Continue most recent conversation
claude --continue

# Continue most recent conversation with a specific prompt
claude --continue --print "Show me our progress"

# Show conversation picker
claude --resume

# Continue most recent conversation in non-interactive mode
claude --continue --print "Run the tests again"

​

Understand new codebases

​

Get a quick codebase overview

When to use: You’ve just joined a new project and need to understand its structure quickly.

cd /path/to/project 

claude 

> give me an overview of this codebase 

> explain the main architecture patterns used here 

> what are the key data models?

> how is authentication handled?

Tips:

• Start with broad questions, then narrow down to specific areas
• Ask about coding conventions and patterns used in the project
• Request a glossary of project-specific terms

​

Find relevant code

When to use: You need to locate code related to a specific feature or functionality.

> find the files that handle user authentication 

> how do these authentication files work together? 

> trace the login process from front-end to database 

Tips:

• Be specific about what you’re looking for
• Use domain language from the project

​

Fix bugs efficiently

​

Diagnose error messages

When to use: You’ve encountered an error message and need to find and fix its source.

> I'm seeing an error when I run npm test 

> suggest a few ways to fix the @ts-ignore in user.ts 

> update user.ts to add the null check you suggested 

Tips:

• Tell Claude the command to reproduce the issue and get a stack trace
• Mention any steps to reproduce the error
• Let Claude know if the error is intermittent or consistent

​

Refactor code

​

Modernize legacy code

When to use: You need to update old code to use modern patterns and practices.

> find deprecated API usage in our codebase 

> suggest how to refactor utils.js to use modern JavaScript features 

> refactor utils.js to use ES2024 features while maintaining the same behavior 

> run tests for the refactored code 

Tips:

• Ask Claude to explain the benefits of the modern approach
• Request that changes maintain backward compatibility when needed
• Do refactoring in small, testable increments

​

Work with tests

​

Add test coverage

When to use: You need to add tests for uncovered code.

> find functions in NotificationsService.swift that are not covered by tests 

> add tests for the notification service 

> add test cases for edge conditions in the notification service 

> run the new tests and fix any failures 

Tips:

• Ask for tests that cover edge cases and error conditions
• Request both unit and integration tests when appropriate
• Have Claude explain the testing strategy

​

Create pull requests

​

Generate comprehensive PRs

When to use: You need to create a well-documented pull request for your changes.

> summarize the changes I've made to the authentication module 

> create a pr 

> enhance the PR description with more context about the security improvements 

> add information about how these changes were tested 

Tips:

• Ask Claude directly to make a PR for you
• Review Claude’s generated PR before submitting
• Ask Claude to highlight potential risks or considerations

​

Handle documentation

​

Generate code documentation

When to use: You need to add or update documentation for your code.

> find functions without proper JSDoc comments in the auth module 

> add JSDoc comments to the undocumented functions in auth.js 

> improve the generated documentation with more context and examples 

> check if the documentation follows our project standards 

Tips:

• Specify the documentation style you want (JSDoc, docstrings, etc.)
• Ask for examples in the documentation
• Request documentation for public APIs, interfaces, and complex logic

​

Work with images

​

Analyze images and screenshots

When to use: You need to work with images in your codebase or get Claude’s help analyzing image content.

> What does this image show? 
> Describe the UI elements in this screenshot 
> Are there any problematic elements in this diagram? 

> Here's a screenshot of the error. What's causing it? 
> This is our current database schema. How should we modify it for the new feature? 

> Generate CSS to match this design mockup 
> What HTML structure would recreate this component? 

Tips:

• Use images when text descriptions would be unclear or cumbersome
• Include screenshots of errors, UI designs, or diagrams for better context
• You can work with multiple images in a conversation
• Image analysis works with diagrams, screenshots, mockups, and more

​

Use extended thinking

​

Leverage Claude’s extended thinking for complex tasks

When to use: When working on complex architectural decisions, challenging bugs, or planning multi-step implementations that require deep reasoning.

> I need to implement a new authentication system using OAuth2 for our API. Think deeply about the best approach for implementing this in our codebase. 

> think about potential security vulnerabilities in this approach 
> think harder about edge cases we should handle 

Tips to get the most value out of extended thinking:

Extended thinking is most valuable for complex tasks such as:

• Planning complex architectural changes
• Debugging intricate issues
• Creating implementation plans for new features
• Understanding complex codebases
• Evaluating tradeoffs between different approaches

The way you prompt for thinking results in varying levels of thinking depth:

• “think” triggers basic extended thinking
• intensifying phrases such as “think more”, “think a lot”, “think harder”, or “think longer” triggers deeper thinking

For more extended thinking prompting tips, see Extended thinking tips.

​

Set up project memory

​

Create an effective CLAUDE.md file

When to use: You want to set up a CLAUDE.md file to store important project information, conventions, and frequently used commands.

> /init 

Tips:

• Include frequently used commands (build, test, lint) to avoid repeated searches
• Document code style preferences and naming conventions
• Add important architectural patterns specific to your project
• CLAUDE.md memories can be used for both instructions shared with your team and for your individual preferences.

​

Use Claude as a unix-style utility

​

Add Claude to your verification process

When to use: You want to use Claude Code as a linter or code reviewer.

Steps:

// package.json
{
    ...
    "scripts": {
        ...
        "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"
    }
}

​

Pipe in, pipe out

When to use: You want to pipe data into Claude, and get back data in a structured format.

cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

​

Control output format

When to use: You need Claude’s output in a specific format, especially when integrating Claude Code into scripts or other tools.

cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt

cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json

cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json

Tips:

• Use --output-format text for simple integrations where you just need Claude’s response
• Use --output-format json when you need the full conversation log
• Use --output-format stream-json for real-time output of each conversation turn

​

Create custom slash commands

Claude Code supports custom slash commands that you can create to quickly execute specific prompts or tasks.

​

Create project-specific commands

When to use: You want to create reusable slash commands for your project that all team members can use.

mkdir -p .claude/commands

echo "Analyze the performance of this code and suggest three specific optimizations:" > .claude/commands/optimize.md 

claude > /project:optimize 

Tips:

• Command names are derived from the filename (e.g., optimize.md becomes /project:optimize)
• You can organize commands in subdirectories (e.g., .claude/commands/frontend/component.md becomes /project:frontend:component)
• Project commands are available to everyone who clones the repository
• The Markdown file content becomes the prompt sent to Claude when the command is invoked

​

Add command arguments with $ARGUMENTS

When to use: You want to create flexible slash commands that can accept additional input from users.

echo "Find and fix issue #$ARGUMENTS. Follow these steps: 1.
Understand the issue described in the ticket 2. Locate the relevant code in
our codebase 3. Implement a solution that addresses the root cause 4. Add
appropriate tests 5. Prepare a concise PR description" >
.claude/commands/fix-issue.md 

claude > /project:fix-issue 123 

Tips:

• The $ARGUMENTS placeholder is replaced with any text that follows the command
• You can position $ARGUMENTS anywhere in your command template
• Other useful applications: generating test cases for specific functions, creating documentation for components, reviewing code in particular files, or translating content to specified languages

​

Create personal slash commands

When to use: You want to create personal slash commands that work across all your projects.

mkdir -p ~/.claude/commands 

echo "Review this code for security vulnerabilities, focusing on:" >
~/.claude/commands/security-review.md 

claude > /user:security-review 

Tips:

• Personal commands are prefixed with /user: instead of /project:
• Personal commands are only available to you and not shared with your team
• Personal commands work across all your projects
• You can use these for consistent workflows across different codebases

​

Run parallel Claude Code sessions with Git worktrees

​

Use worktrees for isolated coding environments

When to use: You need to work on multiple tasks simultaneously with complete code isolation between Claude Code instances.

# Create a new worktree with a new branch 
git worktree add ../project-feature-a -b feature-a

# Or create a worktree with an existing branch
git worktree add ../project-bugfix bugfix-123

# Navigate to your worktree 
cd ../project-feature-a

# Run Claude Code in this isolated environment
claude

cd ../project-bugfix
claude

# List all worktrees
git worktree list

# Remove a worktree when done
git worktree remove ../project-feature-a

Tips:

• Each worktree has its own independent file state, making it perfect for parallel Claude Code sessions
• Changes made in one worktree won’t affect others, preventing Claude instances from interfering with each other
• All worktrees share the same Git history and remote connections
• For long-running tasks, you can have Claude working in one worktree while you continue development in another
• Use descriptive directory names to easily identify which task each worktree is for
• Remember to initialize your development environment in each new worktree according to your project’s setup. Depending on your stack, this might include:
  • JavaScript projects: Running dependency installation (npm install, yarn)
  • Python projects: Setting up virtual environments or installing with package managers
  • Other languages: Following your project’s standard setup process

​

Next steps