Git Workflows and Best Practices for Teams

Git is powerful but can become chaotic without conventions. Good workflows reduce conflicts, enable collaboration, and make history meaningful. AI can help you adopt and maintain effective Git practices.

Branching Strategies#

GitHub Flow (Recommended for Most Teams)#

main (always deployable)
  │
  ├── feature/user-auth
  │     └── PR → main
  │
  ├── feature/payment-integration
  │     └── PR → main
  │
  └── fix/login-bug
        └── PR → main

Rules:

main is always deployable
Branch from main for any change
Open PR for review
Merge to main and deploy

GitFlow (For Scheduled Releases)#

main ─────────────────────────────────────────
       │                    ▲
       │                    │ (release merge)
develop ──────────────────────────────────────
       │         │         ▲
       │         │         │ (feature merge)
  feature/a   feature/b ───┘

When to use: Mobile apps, versioned products, regulated industries.

Trunk-Based Development#

main ──●──●──●──●──●──●──●──●──●──
       │  │  │  │  │  │  │  │  │
       └──┴──┴──┴──┴──┴──┴──┴──┘
       (small, frequent commits)

Rules:

Commit directly to main (or very short-lived branches)
Use feature flags for incomplete work
Deploy continuously

Commit Best Practices#

Commit Message Format#

type(scope): subject

body (optional)

footer (optional)

Types:

feat: New feature
fix: Bug fix
docs: Documentation
style: Formatting
refactor: Code restructuring
test: Adding tests
chore: Maintenance

Examples:

feat(auth): add OAuth2 Google login

Implements Google OAuth2 flow with token refresh.
Stores tokens securely in encrypted session.

Closes #123

fix(cart): prevent negative quantities

Users could enter negative numbers in quantity input,
resulting in negative totals. Added validation.

Atomic Commits#

Each commit should be a single logical change:

# ❌ Bad: Multiple unrelated changes
git commit -m "Fix login bug, add new header, update dependencies"

# ✅ Good: Separate commits
git commit -m "fix(auth): handle expired session redirect"
git commit -m "feat(ui): add responsive header component"
git commit -m "chore(deps): update React to 18.2"

Interactive Rebase for Clean History#

# Before pushing, clean up commits
git rebase -i HEAD~5

# In editor:
pick abc123 feat: add user model
squash def456 fix typo
squash ghi789 add missing field
pick jkl012 feat: add user API
pick mno345 test: add user tests

Pull Request Practices#

PR Template#

## Description
Brief description of changes.

## Type of Change
- [ ] Bug fix
- [ ] New feature
- [ ] Breaking change
- [ ] Documentation

## Testing
- [ ] Unit tests added/updated
- [ ] Integration tests added/updated
- [ ] Manual testing completed

## Checklist
- [ ] Code follows style guidelines
- [ ] Self-reviewed
- [ ] Documentation updated
- [ ] No console.logs or debug code

PR Size Guidelines#

Small PR (Ideal):
- < 200 lines changed
- Single concern
- Reviewable in 15 minutes

Medium PR (Acceptable):
- 200-500 lines
- Related changes
- Reviewable in 30 minutes

Large PR (Avoid):
- > 500 lines
- Consider splitting
- Hard to review thoroughly

Review Etiquette#

As Author:

Respond to all comments
Don't take feedback personally
Explain decisions when asked

As Reviewer:

Be constructive, not critical
Suggest, don't demand
Approve when "good enough"

Handling Common Scenarios#

Merge vs Rebase#

# Merge: Preserves history, creates merge commit
git checkout feature
git merge main

# Rebase: Linear history, rewrites commits
git checkout feature
git rebase main

Use merge when: Preserving context matters, shared branches Use rebase when: Clean history desired, personal branches

Resolving Conflicts#

# During merge/rebase
git status  # See conflicted files

# Edit files to resolve conflicts
# Look for conflict markers:
<<<<<<< HEAD
your changes
=======
their changes
>>>>>>> branch

# After resolving
git add resolved-file.js
git rebase --continue  # or git merge --continue

Recovering from Mistakes#

# Undo last commit (keep changes)
git reset --soft HEAD~1

# Undo last commit (discard changes)
git reset --hard HEAD~1

# Recover deleted branch
git reflog
git checkout -b recovered-branch abc1234

# Undo a pushed commit (creates new commit)
git revert abc1234

Stashing Work#

# Save work in progress
git stash

# Save with message
git stash push -m "WIP: user feature"

# List stashes
git stash list

# Apply and remove
git stash pop

# Apply specific stash
git stash apply stash@{2}

Advanced Patterns#

Git Hooks#

# .git/hooks/pre-commit
#!/bin/sh
npm run lint
npm run test

With Husky:

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged",
      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
    }
  },
  "lint-staged": {
    "*.{js,ts}": ["eslint --fix", "prettier --write"]
  }
}

Bisect for Bug Finding#

# Start bisect
git bisect start
git bisect bad  # Current commit is bad
git bisect good abc123  # Known good commit

# Git checks out middle commit
# Test and mark:
git bisect good  # or git bisect bad

# Repeat until found
# Reset when done
git bisect reset

Worktrees for Parallel Work#

# Work on multiple branches simultaneously
git worktree add ../hotfix hotfix-branch
git worktree add ../feature feature-branch

# Each worktree is independent
cd ../hotfix
# Make changes, commit, push

# Remove when done
git worktree remove ../hotfix

Team Conventions#

Branch Naming#

feature/TICKET-123-user-authentication
fix/TICKET-456-login-redirect
hotfix/critical-security-patch
docs/update-api-documentation
refactor/extract-payment-service

Protected Branches#

# GitHub branch protection
main:
  - Require PR reviews (1-2)
  - Require status checks
  - Require up-to-date branches
  - No force push
  - No deletions

Code Owners#

# .github/CODEOWNERS
*.js @frontend-team
*.ts @frontend-team
/api/** @backend-team
/infrastructure/** @platform-team
*.md @docs-team

Conclusion#

Good Git practices make collaboration smoother and history meaningful. Choose a workflow that fits your team, enforce it with automation, and document conventions clearly.

AI helps write better commit messages, resolve conflicts, and understand complex Git operations. The investment in Git hygiene pays dividends in easier debugging, cleaner reviews, and smoother onboarding.

Share this article