DEV Community

brian austin
brian austin

Posted on

Claude Code git workflows: branches, commits, and rollbacks without leaving your terminal

#claudecode #git #productivity #tutorial

Claude Code git workflows: branches, commits, and rollbacks without leaving your terminal

One of the most underrated Claude Code features is how well it integrates with git. You can do your entire git workflow — branch, code, test, commit, PR — without switching to a terminal or Git GUI.

Here's how I actually use this.

The basic pattern

Every feature starts with a branch:

> create a new branch called feature/user-auth and implement JWT authentication for the /api/users endpoint
Enter fullscreen mode Exit fullscreen mode

Claude will:

  1. Run git checkout -b feature/user-auth
  2. Write the code
  3. Stage and commit with a descriptive message

All in one shot.

Atomic commits by feature

For larger changes, I tell Claude to commit incrementally:

> refactor the payment module. commit after each logical unit of change — data layer, service layer, API layer separately
Enter fullscreen mode Exit fullscreen mode

This gives you a clean, reviewable commit history rather than one massive dump.

Sample output from Claude:

✓ Commit 1: refactor(payment): extract PaymentRepository from PaymentService
✓ Commit 2: refactor(payment): add PaymentService interface and implementation  
✓ Commit 3: feat(payment): update PaymentController to use new service layer
Enter fullscreen mode Exit fullscreen mode

Rollback without panic

When something goes wrong (and it will), Claude handles rollbacks cleanly:

> the tests are failing after your last change. roll back to the previous commit and let's try a different approach
Enter fullscreen mode Exit fullscreen mode

Claude runs git revert HEAD or git checkout -- <files> depending on what's needed, then proposes an alternative.

Parallel feature branches (the real power move)

This is where Claude Code shines for complex projects. You run multiple Claude instances on separate branches simultaneously:

Terminal 1:

git checkout -b feature/payment-v2
claude
> implement the new Stripe payment flow
Enter fullscreen mode Exit fullscreen mode

Terminal 2:

git checkout -b feature/email-notifications  
claude
> implement email notifications using SendGrid
Enter fullscreen mode Exit fullscreen mode

Both run in parallel. No conflicts. Each Claude instance is isolated to its branch.

When both are done:

> review the diff between main and feature/payment-v2 and write a PR description
Enter fullscreen mode Exit fullscreen mode

The commit message pattern

I've found this prompt produces the best commit messages:

> commit this with a conventional commit message: type(scope): description. include what changed and why, not just what
Enter fullscreen mode Exit fullscreen mode

Conventional commits make your git log actually useful:

feat(auth): add refresh token rotation

Previous implementation kept refresh tokens valid indefinitely after use.
Now tokens are rotated on each use to limit the blast radius of token theft.

Breaking change: clients must store and send the new refresh token from each response.
Enter fullscreen mode Exit fullscreen mode

Stash for context switching

When you're mid-feature and need to hotfix something:

> stash the current work-in-progress, switch to main, fix the null pointer crash in UserController.java line 47, commit it, then restore the stash and continue
Enter fullscreen mode Exit fullscreen mode

Claude handles the whole sequence: git stash → git checkout main → fix → commit → git checkout - → git stash pop

Interactive rebase before PR

Before opening a PR:

> clean up the last 5 commits. squash the WIP commits, rewrite the messages to be clear and conventional, and make sure the history tells a coherent story
Enter fullscreen mode Exit fullscreen mode

This is the kind of thing developers avoid because it's tedious. Claude makes it fast.

The rate limit problem with long git sessions

Parallel branches + atomic commits + PR reviews = a lot of Claude back-and-forth. Long git workflow sessions are exactly when you hit rate limits.

The fix: ANTHROPIC_BASE_URL pointing to a proxy.

export ANTHROPIC_BASE_URL=https://simplylouie.com/api/proxy
export ANTHROPIC_API_KEY=your-key
claude
Enter fullscreen mode Exit fullscreen mode

SimplyLouie runs at ✌️2/month — a flat rate that handles as many git sessions as you throw at it.

ChatGPT charges $20/month for less. The math is obvious.

TL;DR git workflow 

# Start feature
> create branch feature/X and implement Y

# Incremental commits  
> commit after each logical unit with conventional commit messages

# When broken
> roll back the last commit and try approach Z instead

# Before PR
> squash and clean up the last N commits, write a PR description

# Parallel work
[Multiple terminals, each on their own branch]
Enter fullscreen mode Exit fullscreen mode

The key insight: Claude Code isn't just a coding tool. It's a git workflow tool. Once you start treating it that way, you ship faster and with a cleaner history.

Running into rate limits on long git sessions? SimplyLouie.com — Claude API proxy, ✌️2/month.

Top comments (0)