Git Workflow

When to use this skill

• Creating meaningful commit messages
• Managing branches
• Merging code
• Resolving conflicts
• Collaborating with team
• Git best practices

Instructions

Step 1: Branch management

Create feature branch:

# Create and switch to new branch
git checkout -b feature/feature-name

# Or create from specific commit
git checkout -b feature/feature-name <commit-hash>

Naming conventions:

• feature/description: New features
• bugfix/description: Bug fixes
• hotfix/description: Urgent fixes
• refactor/description: Code refactoring
• docs/description: Documentation updates

Step 2: Making changes

Stage changes:

# Stage specific files
git add file1.py file2.js

# Stage all changes
git add .

# Stage with patch mode (interactive)
git add -p

Check status:

# See what's changed
git status

# See detailed diff
git diff

# See staged diff
git diff --staged

Step 3: Committing

Write good commit messages:

git commit -m "type(scope): subject

Detailed description of what changed and why.

- Change 1
- Change 2

Fixes #123"

Commit types:

• feat: New feature
• fix: Bug fix
• docs: Documentation
• style: Formatting, no code change
• refactor: Code refactoring
• test: Adding tests
• chore: Maintenance

Example:

git commit -m "feat(auth): add JWT authentication

- Implement JWT token generation
- Add token validation middleware
- Update user model with refresh token

Closes #42"

Step 4: Pushing changes

# Push to remote
git push origin feature/feature-name

# Force push (use with caution!)
git push origin feature/feature-name --force-with-lease

# Set upstream and push
git push -u origin feature/feature-name

Step 5: Pulling and updating

# Pull latest changes
git pull origin main

# Pull with rebase (cleaner history)
git pull --rebase origin main

# Fetch without merging
git fetch origin

Step 6: Merging

Merge feature branch:

# Switch to main branch
git checkout main

# Merge feature
git merge feature/feature-name

# Merge with no fast-forward (creates merge commit)
git merge --no-ff feature/feature-name

Rebase instead of merge:

# On feature branch
git checkout feature/feature-name

# Rebase onto main
git rebase main

# Continue after resolving conflicts
git rebase --continue

# Abort rebase
git rebase --abort

Step 7: Resolving conflicts

When conflicts occur:

# See conflicted files
git status

# Open files and resolve conflicts
# Look for markers:
<<<<<<< HEAD
Current branch code
=======
Incoming branch code
>>>>>>> feature-branch

# After resolving
git add <resolved-files>
git commit  # For merge
git rebase --continue  # For rebase

Step 8: Cleaning up

# Delete local branch
git branch -d feature/feature-name

# Force delete
git branch -D feature/feature-name

# Delete remote branch
git push origin --delete feature/feature-name

# Clean up stale references
git fetch --prune

Advanced workflows

Interactive rebase

# Rebase last 3 commits
git rebase -i HEAD~3

# Commands in editor:
# pick: use commit
# reword: change commit message
# edit: amend commit
# squash: combine with previous
# fixup: like squash, discard message
# drop: remove commit

Stashing changes

# Stash current changes
git stash

# Stash with message
git stash save "Work in progress on feature X"

# List stashes
git stash list

# Apply most recent stash
git stash apply

# Apply and remove stash
git stash pop

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

# Drop stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

Cherry-picking

# Apply specific commit
git cherry-pick <commit-hash>

# Cherry-pick multiple commits
git cherry-pick <hash1> <hash2> <hash3>

# Cherry-pick without committing
git cherry-pick -n <commit-hash>

Bisect (finding bugs)

# Start bisect
git bisect start

# Mark current as bad
git bisect bad

# Mark known good commit
git bisect good <commit-hash>

# Git will checkout commits to test
# Test and mark each:
git bisect good  # if works
git bisect bad   # if broken

# When found, reset
git bisect reset

Examples

Example 1: Feature development workflow

# 1. Create feature branch
git checkout main
git pull origin main
git checkout -b feature/user-profile

# 2. Make changes
# ... edit files ...

# 3. Commit changes
git add src/profile/
git commit -m "feat(profile): add user profile page

- Create profile component
- Add profile API endpoints
- Add profile tests"

# 4. Keep up to date with main
git fetch origin
git rebase origin/main

# 5. Push to remote
git push origin feature/user-profile

# 6. Create Pull Request on GitHub/GitLab
# ... after review and approval ...

# 7. Merge and cleanup
git checkout main
git pull origin main
git branch -d feature/user-profile

Example 2: Hotfix workflow

# 1. Create hotfix branch from production
git checkout main
git pull origin main
git checkout -b hotfix/critical-bug

# 2. Fix the bug
# ... make fixes ...

# 3. Commit
git add .
git commit -m "hotfix: fix critical login bug

Fixes authentication bypass vulnerability

Fixes #999"

# 4. Push and merge immediately
git push origin hotfix/critical-bug

# After merge:
# 5. Cleanup
git checkout main
git pull origin main
git branch -d hotfix/critical-bug

Example 3: Collaborative workflow

# 1. Update main branch
git checkout main
git pull origin main

# 2. Create feature branch
git checkout -b feature/new-feature

# 3. Regular updates from main
git fetch origin
git rebase origin/main

# 4. Push your work
git push origin feature/new-feature

# 5. If teammate made changes to your branch
git pull origin feature/new-feature