Git & GitHub For Absolute Beginners [2026]

Explore the git workflow and core concepts, including initializing repositories, recording history, staging changes, and committing, to build a solid foundation for version control.

Initialize a git repository in your project folder and learn that the hidden dot git directory stores your project history.

Learn the Git workflow from init to history: stage changes in the staging area with git add, commit with meaningful messages, and review history including IDs, dates, and authors.

Practice building a rough Git workflow from memory by drawing it with two commands, then upload a photo for review in Q&A and verify your work against the previous lesson.

Learn to add files to the staging area with git add, check status with git status, and stage changes before committing.

Master the commit workflow: stage files, run git commit with a message using -m, and write multi-line descriptions in the editor; verify with git status for a clean working tree.

Avoid committing every tiny change or large batches. Commit at meaningful checkpoints in the staging area and git repository, keeping each commit a logically separate unit with a clear message.

Practice a git workflow by creating chapter two dot txt, staging it with git add, and committing with git commit -m, illustrating untracked files and quick solutions.

Discover how to skip the staging area with git commit -a or -am, and use this only when you are sure you do not need to review your code.

Delete chapter two from the local area and staging area by removing it in the working directory, then use git status, git add, and git commit; or run git rm.

ignore files in git with a dot gitignore, excluding logs, node_modules, and specific files, while managing untracked status and using git rm --cached when needed.

See exact changes with git diff, compare local working files against staging and commits, and configure VS Code as the diff tool for side-by-side views, minus and plus lines.

Master the git status -s shortcut to see changes, understand the staging area versus the working directory, and use git add to stage files so modified markers disappear after commit.

Explore git log to view commit history with each commit's unique ID, author, date, time, and message; use --oneline, --reverse, space paging, and q to quit.

Unstage changes with git restore --staged to move edits back to the working directory and learn how the staging area and commit interact.

Learn to discard changes in local files by restoring from the staging area using git restore, and clean untracked files with git clean -f -d, then verify with git status.

discover how git tracks file history, remove chapter one.txt with git rm and commit, then restore it from a prior commit using git log --oneline and git restore --source.

Learn to perform basic git operations in VS Code using the source control panel, including staging changes, committing, and viewing the changes list and file history timeline.

Discover the GitHub Desktop GUI, a beginner-friendly way to use git. Create or open repositories, stage changes, commit with messages, and review commit history.

Explore git's graphical user interface with Gitkraken, and compare it to GitHub Desktop. Install and sign in, then open, clone, or create repositories while reviewing commits and file changes.

Explore detailed git history by listing all commits, filtering by author, date, and message, and setting shortcuts for long commands. Compare specific commits, use blame, tag commits, and detect bugs.

Clone a Git project for practice using the resources folder. Unzip the course Task Track zip, copy the folder, and paste it into your projects folder to start using.

Explore the git log command in detail, viewing full commit details including author, date, time, and message, and learn to use oneline, stat, and patch options to see file changes.

Filter git history by author, date, and commit messages using --author, --before, --after, --grep, and -i, then view last commits or file history with double dash separation and patch options.

Learn how to create git aliases to save time by mapping long commands to short shortcuts, using git config --global alias, testing with git log, and updating or removing aliases.

Master viewing details of a specific commit with git show, explore head and previous commits using tilde, view changed files with --name-only, and inspect full file content with colon paths.

Use git diff to compare any two commits and see what changed, including the difference between your working directory and the last commit, and file-level diffs like css/style.css.

Learn how to restore code to a specific commit with git checkout, understand detached head state, and navigate master, head, and branches to review commits.

Identify the bug commit efficiently using git bisect by marking bad and good commits, narrowing to the exact culprit without checking every commit.

Learn to use git short log to view contributors, the number of commits per user, and the commit message summaries, with options like -h, -n or --numbered, and -s.

Browse the history of a file with git log, narrowing to index.html using --oneline; view changes with --stat and see actual diffs with --patch, all through practice.

Learn to use git blame to identify the author of each line, with the commit reference and timestamp. Filter to specific lines using -L.

Learn how to mark git commits with tags to version releases, using lightweight and annotated tags, checking out versions, listing, and removing tags.

Open your project in the GitHub desktop app, add a local repository, and browse commit history with messages, authors, and references, noting limited filtering and a simple interface.

Explore how to browse commit history in VS Code with the GitLens extension and in GitKraken, using commit graphs, filters, and file diffs to inspect changes.

Explore Git branches, learn how to create, view, compare, and merge them, and resolve conflicts, preparing you to master essential branching in Git.

Explore how git branches let you add features in isolation, like a drag and drop feature, without touching the master. Learn how master and head pointers track commits across branches.

Create and manage a feature branch for drag and drop using git branch, git switch, and commits, then review branch isolation and merge workflows.

See how to review commits between master and a feature branch using git log master..feature/d, view diffs with git diff master..feature/d, and use --name-only or --name-status to list changes.

Learn how to save unfinished work with git stash when you can't commit, stash changes with a message, view and apply or drop them, and stash untracked files with --all.

Learn to merge a feature branch into master using fast-forward or three-way merges, including switching branches, staging changes, and creating merge commits.

Explore fast-forward merging, creating a linear commit path by merging a feature branch into master, and learn to visualize commits with git log --oneline --all and the graph option.

Master non fast-forward merging in Git by creating and switching branches and performing merges with --no-ff. Analyze merge commits, history graphs, and the trade-offs between fast-forward and non fast-forward merges.

Explore how three way merging resolves diverged branches by creating a new merge commit that combines changes from feature and master, using git merge.

Learn to keep your git repository tidy by removing merged branches from master, using git branch --merged and git branch -d, and identify unmerged branches with git branch --no-merged.

Learn how to resolve merge conflicts in git when merging master and feature/login, with index.html and script.js edits creating conflicts and practical resolution steps.

Abort a merge when a conflict occurs by mistake using Git merge --abort to back out of the merging state.

We can move the head and master pointers back to the previous commit with git reset --hard, or revert the merge with a new commit to avoid rewriting history.

Learn how to undo a merge by reverting the merge commit using git revert, choosing the first or second parent with -m, and why revert preserves history.

Squash merge combines bad commits into a single commit, creating a clean, linear history before merging branches and dropping unnecessary checkpoints.

Rebase a feature branch to master, creating a linear history and avoiding unnecessary merges. Learn why rebasing rewrites history and how to perform it locally with git rebase master.

Resolve conflicts during a git rebase by creating a branch, editing index.html, staging and committing changes, and using git rebase options to continue, skip, or abort while diverged branches.

Learn to copy a single commit from one branch to another using cherry pick, handle conflicts, and commit the changes without merging.

Copy a single file from one git branch to another using git restore with a source branch and precise file path, demonstrated by syncing script.js from fixed bug/auth into master.

Learn branch and merge workflows in VS Code using source control, create and switch branches, compare changes, merge options (fast forward, squash), and revert commits with GitLens commit graph.

Demonstrate branch creation, switching, and merging in the GitHub Desktop app, including resolving conflicts in VS Code, viewing merge commits, and accessing branch options.

Explore how to manage branches and merges in GitKraken, including creating a feature/logout branch, committing changes, comparing branches, resolving conflicts with the merge tool, and performing revert and reset operations.

Learn to collaborate on a single project using git with a cloud repository. Patch changes from teammates, publish your updates, manage pull request issues, and other team workflows.

Explore how teams collaborate on a single project with git, using a centralized workflow on GitHub. Clarify centralized vs distributed version control and basic operations like clone, push, and pull.

Learn how to upload a local git project to GitHub using GitHub Desktop and GitKraken, including publishing a repository, choosing public or private, and verifying via GitHub.

Learn how to create a new repository on GitHub, choose public or private visibility, add a README and gitignore, and review commits and branches in your project.

Add team members as collaborators to a public git repository by using the collaborators tab in settings; invite users, manage pending invites, and understand acceptance or rejection of access.

Clone the repository from GitHub via the code link and git clone, then view commits with git log and learn how origin, main, and head pointers relate to remote repository.

Learn how to fetch remote changes from origin/main into your local git repository, inspect commits, and perform a fast-forward merge to update your working directory.

Learn how git pull combines remote changes with your local commits, compare merge and rebase for a linear history, and follow a practical workflow with local and remote commits.

Push local changes to the remote with git push origin main, verify history, and use git pull, merge or rebase to resolve diverging histories without force push.

Learn how to create version tags in git, push them to the remote origin, verify on GitHub, and remove tags locally or remotely.

Create releases in GitHub to describe a version and communicate changes to your team. Attach binaries, mark pre-release, and publish release notes with a clear heading.

Create and manage branches with git switch, and push to the remote origin. Set an upstream remote tracking branch to simplify push and pull between local and remote.

Learn to collaborate on a git branch through a real-world home page feature, using clone, pull requests, merges, conflict resolution, and eventual integration into the main branch.

Explore practical techniques for working with branches in git, including creating, fetching, linking remote tracking branches, switching, committing, pushing, merging, handling conflicts, and pruning remote branches.

Create pull requests on GitHub to open discussions and request reviews, then merge changes with team feedback. Push branches, set upstream, and compare base and target branches before merging.

Resolve pull request conflicts by using GitHub or command line, following a feature branch workflow with edits to index.html and script.js, pushing, and merging after resolving.

Create new issues in GitHub, write titles and descriptions, attach demo images, assign teammates, apply labels, and link issues to pull requests to automate closing after merges.

Learn how to add milestones in GitHub to plan timelines, set dates and descriptions, assign issues, and track progress as milestones close when issues are completed.

Fork open source projects on GitHub, push changes to your repository, and create pull requests for review and merging.

Search repository, review issues, and pick a project to contribute to. Fork the project, clone it, create a branch, commit changes, push, and open a pull request for review.

Sync a fork with the base repository using git fetch and git merge to keep both repositories up to date. Switch to master and merge origin/master to update.

Explore collaboration in the GitHub desktop app, including renaming the readme, committing with clear messages, pushing to origin, pulling updates, and creating pull requests.

Explore collaboration with gitkraken, including opening a fork, managing branches and remotes, pulling and pushing, creating pull requests, handling issues, and resolving conflicts.

Master git commit history management by undoing and reverting commits, recovering lost work, dropping or changing messages, and splitting or squashing commits to rewrite history.

Rewrite Git history to keep commits clean from bad commit messages, showing features and fixes. Do not rewrite remote history; only local edits, with the next lesson exploring undoing commits.

Undo commits in git using reset with soft, mixed, and hard options to move the head. Describe how each option changes the staging area and working directory.

Master reverting commits pushed to a remote, creating new revert commits instead of altering history. Explore reverting single or multiple commits and batching with --no-commit to prepare a single revert.

Recover lost commits with git reflog by viewing head pointer history and restoring the previous reference using the commit id or git reset --hard.

Learn to amend any commit in git history using interactive rebase, changing previous commits without altering pushed history, by editing commits and completing the rebase to create new commits.

Learn to drop a full commit from history using git rebase -i, addressing work-in-progress commits, handling conflicts with the merge tool, and preserving or removing affected files.

Change commit messages using git rebase -i and reword to rewrite history with clear messages, and learn to handle local commits safely before pushing to remote.

Reorder commits in git history using interactive rebasing (git rebase -i) by moving lines in the rebase script, then save to update the history.

Learn to squash two or more commits using interactive rebase, choose between squash and fixup, edit the final message, and undo with reflog and reset.

Learn to split a large Git commit into smaller ones using git rebase -i, edit, and reset --mixed to separate cart page and user profile changes, achieving a linear history.

Learn how to rewrite history with GitKraken via an interactive rebase, reword, squash, and drop commits, resolve conflicts, and understand when to use terminal versus GUI tools for advanced actions.

Celebrate completing the ultimate git and GitHub course, reflect on learning git concepts, and invite viewers to leave a rating or review to inspire future students.