Version control is one of the highest-impact skills for any developer because it protects work, improves collaboration and reduces release stress. Git helps you track changes locally, while GitHub helps you share, review and collaborate on those changes.
This guide gives you a practical Git and GitHub workflow you can use on day one, including setup, core commands, branching, pull requests, safe undo strategies and common troubleshooting steps.
Before learning Git, many beginners copy folders manually: project_final, project_final_v2 and project_really_final. That works for a short time, but it quickly becomes risky. You cannot easily see what changed, who changed it or how to return to a clean version.
Git solves this by turning your project history into a clear timeline of commits. Each commit is a checkpoint you can inspect, compare, share or revert.
Version control is useful whether you are working alone on a side project or collaborating on a large application. It helps you experiment safely, review work before merging and recover from mistakes without guessing.
Version control, also known as source control or revision control, is a system that tracks and manages changes to files. For software projects, it records what changed, when it changed and why the change was made.
Version control has become the backbone of modern software development, offering critical advantages that every developer should leverage:
Git is a distributed version control system created by Linus Torvalds, the creator of Linux. It's designed to handle everything from small personal projects to massive codebases with speed and efficiency.
GitHub extends Git by providing hosting, collaboration, review, issue tracking and automation features.
# For macOS (using Homebrew)
brew install git
# For Ubuntu/Debian
sudo apt-get install git
# For Windows
# Download from https://git-scm.com/download/win
# Set your identity
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
# Set default branch name
git config --global init.defaultBranch main
# Configure default editor
git config --global core.editor "code --wait" # For VS Code
# Initialize a new repository
git init my-project
cd my-project
# Or clone an existing one
git clone <repository-url>
One of the most critical steps in setting up a repository is creating a .gitignore file. This tells Git which files to ignore. Never commit:
node_modules or vendor folders.DS_Store/dist, /build).env)Example .gitignore:
node_modules/
.env
.DS_Store
dist/
Before diving into commands, it's crucial to understand the three states of a file in Git:
The basic workflow is:
For the exact commands to perform these actions, check out the Complete Git Command Reference at the end of this guide.
Here is a practical workflow I recommend for beginners:
This habit keeps work reviewable and makes it easier to recover when an experiment goes wrong.
Here is how a small bug fix might look in practice. Imagine your app shows the wrong date format on the profile page.
git pull origin main
git checkout -b fix/profile-date-format
After making the change, review what changed before staging:
git diff
git add src/profile/dateFormatter.js
git commit -m "Fix profile date formatting"
git push -u origin fix/profile-date-format
Then open a pull request that explains the user-visible problem, how you fixed it and how you tested it. This small habit makes code review easier because the reviewer sees one focused change instead of a bundle of unrelated edits.
If the fix turns out to be wrong after merging, prefer a revert:
git revert <commit-hash>
That creates a new commit that undoes the change while preserving history. It is safer for shared branches than rewriting commits others may already have pulled.
main or master: production-ready code.develop: integration branch, if your team uses one.feature/*: new features.hotfix/*: urgent production fixes.# When conflicts occur:
git status # Identify conflicting files
# Resolve conflicts in your editor
git add <resolved-files>
git commit -m "Resolve merge conflicts"
# Undo the last commit but keep changes in your working tree
git reset --soft HEAD~1
# Discard one file only after you are sure it has no useful work
git restore path/to/file
Save changes without committing:
git stash push -m "Work in progress"
git stash pop # Restore changes
Clean up local commit history before sharing:
git rebase -i HEAD~3 # Modify last 3 commits
Do not rewrite commits that other people may already have pulled unless your team explicitly agrees.
Mark important milestones:
git tag -a v1.0 -m "First stable release"
Here are essential Git commands you will use regularly:
# Check status of your working directory
git status # Show modified and staged files
# Stage your changes
git add <file> # Stage specific file
git add . # Stage all changes
# Commit your changes
git commit -m "message" # Save changes with a message
git commit --amend # Edit the last local commit before sharing
# Initialize a new repository
git init # Start a new repo
git clone <repo_url> # Clone existing repo
# List and create branches
git branch -a # List all branches
git checkout -b feature/login # Create and switch to new branch
git merge main # Merge another branch
git branch -d hotfix # Delete local branch
# Managing remotes
git remote add origin <url> # Add remote repository
git push -u origin main # Push and track main branch
git pull # Fetch and merge changes
git fetch # Download objects and refs
git push origin --delete <branch> # Delete remote branch
# View commit history
git log --oneline # Compact history view
git log --graph --oneline --all # Visualize branches
git show <commit> # Show commit details
# Compare differences
git diff # Show unstaged changes
git diff --staged # Show staged changes
git diff branch1 branch2 # Compare two branches
# Stash management
git stash # Temporarily save changes
git stash pop # Apply and remove stash
git stash list # List all stashes
# Tag management
git tag -a v1.0 -m "Release 1.0" # Create annotated tag
git push origin --tags # Push all tags
# Submodule operations
git submodule add <repo> <path> # Add submodule
git submodule update --init # Initialize submodules
# Cleanup commands
git clean -n # Preview untracked files that would be deleted
git clean -fd # Delete untracked files only after checking the preview
git gc # Optimize repository
# Undo operations
git restore <file> # Undo changes in working directory
git reset <file> # Unstage changes
git reset --soft HEAD~1 # Undo last commit but keep changes staged
git revert <hash> # Safe reversal of commits
Avoid destructive commands such as git reset --hard unless you have a verified backup or your team has explicitly agreed to discard the work. For shared branches, git revert is usually safer because it records a new commit instead of rewriting history.
# Basic configuration
git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global core.editor code # Use VS Code
git config --list # View all settings
git diff before staging.main stable and use feature branches for new work..gitignore for generated files, local settings and secrets.GitHub Flow is a lightweight, branch-based workflow that supports teams and projects where deployments are made regularly.
The Workflow:
main.main and delete the branch.GitFlow is a strict branching model designed around project releases.
The Branches:
master: Stores the official release history.develop: Integration branch for features.feature/*: New features that branch off develop.release/*: Preparing a new production release.hotfix/*: Quick patches to production releases.GitFlow can be useful for larger projects with scheduled release cycles, but it may be too heavy for small teams that deploy frequently.
git checkout main # Return to main branch
git checkout -b recovery # Save detached state work first, if needed
git reset --soft HEAD~1 # Keep changes while undoing the last local commit
git fetch origin
git pull --rebase origin main
Review any conflicts carefully before pushing again.
Git is the version control tool that tracks changes on your computer. GitHub is an online platform that hosts Git repositories and adds collaboration features such as pull requests, issues and Actions.
Commit whenever you finish a small, meaningful step. A good commit is easy to describe in one sentence and easy to review later.
Most beginners should start with GitHub Flow because it is simpler: create a branch, commit changes, open a pull request, review and merge into main.
git reset --hard safe?git reset --hard discards local changes and can permanently remove work if you do not have another copy. Use safer commands like git restore, git reset --soft or git revert unless you are completely sure.
Version control with Git and GitHub is a fundamental skill that will serve you throughout your development career. By mastering these tools, you'll:
The key to mastering Git is practice. Start with basic commands and gradually add more advanced features as you become comfortable.
Git becomes easier when you treat every commit as a small checkpoint in your thinking. Commit clear work, branch for experiments, review before merging and keep secrets out of the repository.
Learning to code can feel confusing at first because there are many languages, tools, tutorials and opinions. One person says to start with Python, another recommends JavaScript and someone else says
Read MoreClean code pays long-term dividends on real software teams: fewer regressions, faster onboarding, easier reviews and simpler releases. It is not about making code look clever. It is about making futu
Read MoreStrong API design decisions reduce bugs, support faster frontend integration and make future scaling much easier. A good REST API is predictable: clients know where resources live, which HTTP methods
Read More
