autohandai 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 featuresbugfix/description: Bug fixeshotfix/description: Urgent fixesrefactor/description: Code refactoringdocs/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 featurefix: Bug fixdocs: Documentationstyle: Formatting, no code changerefactor: Code refactoringtest: Adding testschore: 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 --rebase
# 6. Resolve any conflicts
# ... resolve conflicts ...
git add .
git rebase --continue
# 7. Force push after rebase
git push origin feature/new-feature --force-with-lease
Best practices
- Commit often: Small, focused commits
- Meaningful messages: Explain what and why
- Pull before push: Stay updated
- Review before commit: Check what you're committing
- Use branches: Never commit directly to main
- Keep history clean: Rebase feature branches
- Test before push: Run tests locally
- Write descriptive branch names: Easy to understand
- Delete merged branches: Keep repository clean
- Use .gitignore: Don't commit generated files
Common patterns
Undo last commit (keep changes)
git reset --soft HEAD~1
Undo last commit (discard changes)
git reset --hard HEAD~1
Amend last commit
# Change commit message
git commit --amend -m "New message"
# Add files to last commit
git add forgotten-file.txt
git commit --amend --no-edit
View history
# Detailed log
git log
# One line per commit
git log --oneline
# With graph
git log --oneline --graph --all
# Last 5 commits
git log -5
# Commits by author
git log --author="John"
# Commits in date range
git log --since="2 weeks ago"
Find commits
# Search commit messages
git log --grep="keyword"
# Search code changes
git log -S "function_name"
# Show file history
git log --follow -- path/to/file
Troubleshooting
Accidentally committed to wrong branch
# 1. Create correct branch from current state
git branch feature/correct-branch
# 2. Reset current branch
git reset --hard HEAD~1
# 3. Switch to correct branch
git checkout feature/correct-branch
Need to undo a merge
# If not pushed yet
git reset --hard HEAD~1
# If already pushed (creates revert commit)
git revert -m 1 <merge-commit-hash>
Recover deleted branch
# Find lost commit
git reflog
# Create branch from lost commit
git checkout -b recovered-branch <commit-hash>
Sync fork with upstream
# Add upstream remote
git remote add upstream https://github.com/original/repo.git
# Fetch upstream
git fetch upstream
# Merge upstream main
git checkout main
git merge upstream/main
# Push to your fork
git push origin main
Git configuration
User setup
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
Aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.lg 'log --oneline --graph --all'
Editor
git config --global core.editor "code --wait" # VS Code
git config --global core.editor "vim" # Vim