SKILL.md
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-nameOr create from specific commit
git checkout -b feature/feature-name
**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 --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