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 < hash 1

< hash 2

< hash 3

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

References Pro Git Book Git Cheat Sheet Conventional Commits Git Flow GitHub Flow

安装

Create and switch to new branch

Or create from specific commit

Stage specific files

Stage all changes

Stage with patch mode (interactive)

See what's changed

See detailed diff

See staged diff

Push to remote

Force push (use with caution!)

Set upstream and push

Pull latest changes

Pull with rebase (cleaner history)

Fetch without merging

Switch to main branch

Merge feature

Merge with no fast-forward (creates merge commit)

On feature branch

Rebase onto main

Continue after resolving conflicts

Abort rebase

See conflicted files

Open files and resolve conflicts

Look for markers:

After resolving

For merge

For rebase

Delete local branch

Force delete

Delete remote branch

Clean up stale references

Rebase last 3 commits

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

Stash current changes

Stash with message

List stashes

Apply most recent stash

Apply and remove stash

Apply specific stash

Drop stash

Clear all stashes

Apply specific commit

Cherry-pick multiple commits

Cherry-pick without committing

Start bisect

Mark current as bad

Mark known good commit

Git will checkout commits to test

Test and mark each:

if works

if broken

When found, reset

1. Create feature branch

2. Make changes

... edit files ...

3. Commit changes

4. Keep up to date with main

5. Push to remote

6. Create Pull Request on GitHub/GitLab

... after review and approval ...

7. Merge and cleanup

1. Create hotfix branch from production

2. Fix the bug

... make fixes ...

3. Commit

4. Push and merge immediately

After merge:

5. Cleanup

1. Update main branch

2. Create feature branch

3. Regular updates from main

4. Push your work

5. If teammate made changes to your branch