This guide presents recommended Git workflows that will help you develop more efficiently and collaborate more effectively. By following these recommendations, you'll avoid common pitfalls, minimize merge conflicts, and maintain a clean, understandable project history.
🎥 Video: Git patterns and anti-patterns (20 mins) - Learn the patterns used by professional developers
Whether you're working independently or as part of a team, adopting a consistent Git workflow offers numerous benefits:
You can create a new Git repository either locally or on GitHub first.
Alternatively, you can create a repository on your local machine and then push it to GitHub:
# Navigate to your project directory
$ cd my-project
# Initialize a new Git repository
$ git init
Initialized empty Git repository in /path/to/my-project/.git/
# Add files to the repository
$ git add .
# Make the first commit
$ git commit -m "Initial commit"
[main (root-commit) 1a2b3c4] Initial commit
3 files changed, 25 insertions(+)
create mode 100644 README.md
create mode 100644 index.html
create mode 100644 styles.cssAfter creating your repository locally, you'll need to...
# Then connect your local repository
$ git remote add origin https://github.com/username/repository-name.git
# Push your local repository to GitHub
$ git push -u origin main🎥 Video: Creating a Git Repository (7 mins) - Step-by-step walkthrough of creating a repository
Cloning creates a local copy of a remote repository on your machine.
# Clone a repository using HTTPS
$ git clone https://github.com/username/repository.git
# Clone a repository using SSH (requires SSH key setup)
$ git clone git@github.com:username/repository.git
# Clone a specific branch
$ git clone -b branch-name https://github.com/username/repository.git
# Clone to a specific directory
$ git clone https://github.com/username/repository.git my-directory
When you clone a repository, Git automatically:
main or master)💡 Tip: If the repository is large, you can use a shallow clone to speed things up:
git clone --depth=1 https://github.com/username/repository.git
🎥 Video: Git Clone Command (8 mins) - How to clone repositories effectively
After modifying files in your repository, you need to track and commit those changes.
Files in a Git repository exist in one of three states:
Use git add to stage files for the next commit:
# Stage a specific file
$ git add filename.js
# Stage all files in the current directory
$ git add .
# Stage all changes (including deleted files)
$ git add -A
# Interactively stage parts of files
$ git add -pAfter staging your changes, commit them with a descriptive message:
# Commit with a message
$ git commit -m "Add user authentication feature"
[main a1b2c3d] Add user authentication feature
2 files changed, 35 insertions(+), 5 deletions(-)
# Commit and skip the staging area (only works for tracked files)
$ git commit -am "Fix typo in README"
[main b2c3d4e] Fix typo in README
1 file changed, 1 insertion(+), 1 deletion(-)
# Subsequent commits
$ git commit -m "Add login form validation"
[main d4e5f6g] Add login form validation
1 file changed, 10 insertions(+), 1 deletion(-)
$ git commit -m "Fix navbar"
[main e5f6g7h] Fix navbar
1 file changed, 1 insertion(+), 1 deletion(-)
$ git commit -m "Add user auth"
[main f6g7h8i] Add user auth
1 file changed, 10 insertions(+), 1 deletion(-)
⚠️ Best Practice: Write clear, descriptive commit messages that explain why a change was made, not just what was changed.
🎥 Video: Git Add & Commit Tutorial (10 mins) - Detailed explanation of tracking and committing
After committing changes locally, you need to push them to the remote repository to share them with others.
# Push commits to the remote repository
$ git push origin main
# Push all branches to the remote repository
$ git push --all origin
# Force push (use with caution!)
$ git push -f origin main
⚠️ Warning: Force pushing (
git push -f) overwrites the remote branch with your local branch. This can erase others' commits! Only use it when absolutely necessary and when you understand the consequences.
🎥 Video: Git Push Command Explained (7 mins) - Understanding how to push changes to remote repositories
When others have pushed changes to the remote repository, you'll need to pull those changes to keep your local repository up to date.
# Pull changes from the remote repository
$ git pull origin main
# Pull changes and rebase instead of merge
$ git pull --rebase origin main
# Fetch changes without automatically merging
$ git fetch origin
The difference between git pull and git fetch:
git pull fetches changes and automatically merges them into your current branchgit fetch only downloads the changes without integrating them, giving you a chance to review before merging💡 Tip: Get in the habit of pulling changes before you start working each day to avoid merge conflicts.
🎥 Video: Git Pull vs Fetch (8 mins) - Understanding the difference between pull and fetch
Regularly checking the status of your repository helps you understand what changes have been made and what needs to be committed.
# Check the status of your repository
$ git status
On branch main
Your branch is up to date with 'origin/main'.
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: src/components/Button.js
Untracked files:
(use "git add <file>..." to include in what will be committed)
src/components/Modal.js
# Check short status
$ git status -s
M src/components/Button.js
?? src/components/Modal.js💡 Tip: In the short status output,
Mmeans modified,Ameans added,Dmeans deleted, and??means untracked.
Other useful status commands:
# View commit history
$ git log
# View commit history with graph
$ git log --graph --oneline --all
# View changes between working directory and staging area
$ git diff
# View changes between staging area and last commit
$ git diff --staged🎥 Video: Git Status & Log Commands (6 mins) - Learn to check the status of your repository effectively
When working alone on a project, you can follow this simple workflow:
Step-by-step:
# 1. Start by pulling the latest changes (if repository already exists)
$ git pull origin main
# 2. Create or modify files
# (Work on your project)
# 3. Check the status of your changes
$ git status
# 4. Stage your changes
$ git add .
# 5. Commit your changes with a descriptive message
$ git commit -m "Login form validation"
# 6. Push your changes to the remote repository
$ git push origin main
# 7. Repeat steps 2-6 as you continue working
💡 Tip: Even when working alone, commit frequently with meaningful messages. This creates a detailed history that helps you understand your own development process later.
🎥 Video: Git Workflow for Solo Developers (15 mins) - A complete workflow demonstration for solo projects
When collaborating with others, you'll need a more robust workflow to avoid conflicts:
Step-by-step:
# 1. Always start by pulling the latest changes
$ git pull origin main
# 2. Create a feature branch for your work
$ git checkout -b feature/user-authentication
# 3. Create or modify files
# (Work on your feature)
# 4. Check the status of your changes
$ git status
# 5. Stage your changes
$ git add .
# 6. Commit your changes with a descriptive message
$ git commit -m "Implement login form validation"
# 7. Push your feature branch to the remote repository
$ git push -u origin feature/user-authentication
# 8. Create a Pull Request on GitHub
# 9. After the PR is approved and merged, switch back to main
$ git checkout main
# 10. Pull the latest changes (including your merged PR)
$ git pull origin main
# 11. Repeat steps 2-10 for each new feature or bug fix
⚠️ Caution: Never commit directly to the main branch in a collaborative project. Always create feature branches for your work.
🎥 Video: Git & GitHub Workflow for Teams (18 mins) - Learn how to effectively collaborate using Git and GitHub
Commit messages should clearly explain why a change was made, not just what was changed.
# ❌ Bad commit message
$ git commit -m "Fix stuff"
# ✅ Good commit message
$ git commit -m "Fix navbar overflow on mobile screens"Guidelines for good commit messages:
Example of a comprehensive commit message:
$ git commit -m "Add password strength indicator
This adds a visual indicator that shows password strength as users type.
Strength is calculated based on length, complexity, and common patterns.
Fixes #123"Each commit should represent a single logical change. This makes it easier to:
Guidelines for atomic commits:
Regularly pulling changes helps avoid large merge conflicts.
# Start each work session with a pull
$ git pull origin main
# Pull before creating a new feature branch
$ git pull origin main
$ git checkout -b feature/new-feature
# Pull regularly during the day
$ git pull origin main💡 Tip: If you're working on a feature branch and need to incorporate changes from main, you can use:
git checkout feature/my-feature git pull origin main
🎥 Video: Git Best Practices (15 mins) - Learn professional Git habits and best practices
