Git and Version Control with Claude Code

Git is the tool developers use to save snapshots of their code over time, collaborate with teammates, and track every change ever made to a project. Claude Code works directly inside your terminal alongside Git — it can write commit messages, explain what changed, draft pull request descriptions, and help you untangle merge conflicts.

How Claude Code and Git Work Together

Claude Code does not replace Git. It sits alongside Git in your terminal and helps you use Git more effectively. Think of Claude as a co-pilot — you drive, Claude helps with the map.

Your Terminal Workflow:
──────────────────────────────────────────────
[You write code]
      ↓
[Claude Code helps — reviews, fixes bugs]
      ↓
[You stage changes]  →  git add .
      ↓
[Claude writes commit message]
      ↓
[You commit]         →  git commit -m "..."
      ↓
[You push]           →  git push
      ↓
[Claude writes PR description]
──────────────────────────────────────────────

Writing Better Commit Messages With Claude

A commit message records what changed and why. Weak commit messages like "fix stuff" or "update" make your project history useless. Strong commit messages make it easy to trace every change months later.

What Makes a Good Commit Message

BAD:
  fix bug
  update code
  changes

GOOD:
  fix: prevent crash when user email is empty on login
  feat: add pagination to the /products API endpoint
  refactor: extract sendEmail into a shared utility function

The good format is: [type]: [short description of what changed and why]

Asking Claude to Write Your Commit Message

Prompt:
"Write a commit message for these changes.
Use the conventional commits format (feat/fix/refactor/docs).

[paste git diff output here, or describe the changes]"

To get your git diff output, run git diff --staged in your terminal and paste the result into Claude. Claude reads exactly what lines changed and writes an accurate message.

Conventional Commits Cheat Sheet

feat:     New feature added
fix:      Bug fix
refactor: Code changed without behavior change
docs:     Documentation only
test:     Tests added or fixed
chore:    Build tools, dependencies, configs
style:    Formatting, no logic change
perf:     Performance improvement

Understanding Code Changes With Claude

When you pull new code from a teammate or open source repo and want to understand what changed, paste the diff into Claude and ask for an explanation.

Prompt:
"Explain what changed in this git diff in plain English.
What does this code do differently from before?

[paste git diff output]"

Claude reads the diff and explains it in clear language — no Git expertise required to understand the changes.

Writing Pull Request Descriptions

A pull request (PR) description tells your teammates what you built, why you built it, and how to test it. Writing a good one takes time. Claude Code writes it for you in seconds.

PR Description Prompt

Prompt:
"Write a pull request description for these changes.
Include: what changed, why it was needed, and how
to test it manually.

Branch: feature/user-authentication
Changes: [describe what you built or paste the diff]"

PR Description Template Claude Follows

## Summary
[What this PR does in 1–2 sentences]

## Why
[The problem this solves or feature this adds]

## Changes
- [Change 1]
- [Change 2]
- [Change 3]

## How to Test
1. [Step 1]
2. [Step 2]
3. [Expected result]

## Notes
[Anything reviewers should watch out for]

Resolving Merge Conflicts With Claude

A merge conflict happens when two people change the same lines of code in different ways. Git cannot decide which version to keep, so it marks the conflict and asks you to resolve it manually. This looks intimidating — Claude makes it straightforward.

What a Merge Conflict Looks Like

function getUser(id) {
<<<<<<< HEAD
  return db.findById(id);
=======
  return db.users.findOne({ id });
>>>>>>> feature/refactor-db
}

The section between <<<<<<< and ======= is your version. The section between ======= and >>>>>>> is the incoming version from the other branch.

Resolving With Claude

Prompt:
"I have a merge conflict in this file. Help me resolve it.
My version is on HEAD. The incoming version is from
the feature/refactor-db branch.
Which version should I keep, or should I combine them?

[paste the conflict block]"

Claude reads both versions, explains what each one does, and recommends how to resolve the conflict — either keep one, keep the other, or merge the logic from both.

Undoing Mistakes With Claude's Help

Git has multiple ways to undo things, and picking the wrong one can make the situation worse. Claude helps you choose the right Git undo command for your specific situation.

Prompt:
"I committed a file I did not mean to commit.
The commit is local — I haven't pushed yet.
How do I remove that one file from the commit
without losing my other changes?"

Common Undo Scenarios

Situation                    │ Command Claude suggests
─────────────────────────────┼──────────────────────────────
Undo last commit, keep files │ git reset --soft HEAD~1
Undo staged file             │ git restore --staged filename
Discard all uncommitted work │ git checkout .
Undo a pushed commit safely  │ git revert [commit-hash]
Go back to a past commit     │ git checkout [commit-hash]

Always describe your exact situation to Claude rather than asking for a generic undo. The right command depends on whether you pushed, whether you want to keep the files, and how many commits you want to undo.

Using Claude to Review Git History

Git stores every change ever made. Claude helps you make sense of that history when you need to trace a bug back to its origin.

Prompt:
"This function broke sometime in the last week.
Here is the git log output for this file.
Which commit is most likely the one that introduced the bug?

[paste git log output]"

Claude reads the commit messages and timestamps, identifies the most suspicious commit, and tells you how to inspect it with git show [commit-hash].

Creating .gitignore Files

A .gitignore file tells Git which files to never track — like environment files, API keys, build output, and dependency folders. Claude generates these for your specific tech stack.

Prompt:
"Create a .gitignore file for a Node.js project
that uses Next.js, has a .env file for secrets,
and stores build output in the /dist folder."

Claude returns a ready-to-use .gitignore file covering all the common exclusions for that stack.

Branch Naming Conventions

Ask Claude to generate consistent branch names based on your task description. Consistent naming makes it easy to understand what each branch is for without opening it.

Prompt:
"Give me a good branch name for adding a forgot
password feature to the user authentication system."

Claude's output:
  feat/forgot-password-flow
  or
  feature/user-auth-forgot-password

Key Points

  • Claude Code works alongside Git in your terminal — it does not replace it
  • Paste your git diff --staged output into Claude to get an accurate, professional commit message
  • Use conventional commits format: feat, fix, refactor, docs, test, chore
  • Claude writes pull request descriptions in seconds — give it the branch name and a summary of changes
  • Paste merge conflict blocks into Claude and ask which version to keep or how to combine them
  • Always describe your exact undo situation to Claude so it recommends the right Git reset command
  • Claude generates .gitignore files for any tech stack — just name your tools
Previous lessons
Back to courses
Next lessons

Leave a Comment