How Git & GitHub Work Together

By KT | December 14, 2025

Hey There, welcome back or welcome to The Dev Anvil, where we’re always forging better code. If you've noticed things have been a little quiet at The Dev Anvil recently. If you're seeing this post, thank you for sticking around! I took a necessary pause to focus on some intense professional projects, and I genuinely appreciate your patience. While the site was quiet, I was gaining new, real-world development insights that I'm now eager to share. I'm excited to be back in the swing of things, and I promise to make up for the silence by delivering high-quality, practical content, starting with this post!

In our last post, we discussed the foundational concept of Version Control Systems (VCS) and why they are essential for tracking changes, enabling collaboration, and providing a safety net for any modern project.

Today, we're diving into the tools that bring that concept to life: Git and GitHub. While Git is the powerful, free, and open-source version control system that runs locally on your computer (acting as a "time machine" for your code ), GitHub is the popular cloud-based platform that provides the online infrastructure, collaboration features, and remote repository hosting. Together, these two tools are fundamental to modern software development, and understanding how they work in tandem is the key to efficient teamwork and project management.

Git: The Version Control System

Git is a free, open-source version control system (VCS) that runs locally on your computer. Its primary purpose is to track changes in files and projects over time. Imagine it as a "time machine" for your code.

• Tracking Changes: Git records every modification made to your project files, allowing you to see who made what changes, when, and why.


• Snapshots (Commits): When you're happy with a set of changes, you "commit" them. A commit is a snapshot of your project at a specific point in time, along with a message describing the changes.


• Branches: Git enables you to create "branches," which are separate lines of development. This allows you to work on new features or bug fixes without affecting the main codebase until they are ready to be merged.


• Reverting Changes: If you introduce a bug or decide against a particular change, Git allows you to easily revert to previous versions of your files or even entire projects.

Key Git Commands:

• git init: Initializes a new Git repository in a project folder.
• git status: Shows the current state of your files (modified, staged, untracked).
• git add <file(s)>: Adds file changes to the staging area.
• git commit -m "message": Records the staged changes as a new commit in your local history.
• git branch <name>: Creates a new line of development (a branch) to work on features or fixes in isolation.
• git checkout <branch-name> (or git switch): Switches between branches.
• git merge <branch-name>: Integrates changes from one branch into your current active branch.

GitHub: The Cloud-Based Collaboration Platform

GitHub is a popular cloud-based platform that hosts Git repositories and provides a web-based interface for managing and collaborating on projects. It leverages Git's capabilities and adds features for teamwork and project management.

• Remote Repositories: GitHub provides a central location (a "remote repository") to store your Git projects online. This allows multiple developers to access, contribute to, and synchronize their work.


• Collaboration Tools: GitHub offers features like pull requests (for proposing and reviewing changes), issue tracking (for managing bugs and tasks), and project boards, all designed to streamline collaborative development.


• Open Source Hosting: GitHub is a widely used platform for hosting open-source projects, making it easy for developers worldwide to contribute and learn from each other's code.

Key GitHub Features for Collaboration:

1. Forks: A fork is a personal copy of a repository that lives on your GitHub account, allowing you to experiment freely without affecting the original project.


2. Pull Requests (PRs): A pull request is a proposal to merge changes from your branch (or fork) into another branch (e.g., the main branch). This allows collaborators to review and discuss code before it is integrated.

A Basic Git & GitHub Workflow

In the last post, I talked about how to install Git on your computer, how to initialize a repository and how to connect that local repository to a remote host (e.g GitHub). Now I’m going to show you a basic Git & GitHub Workflow.

A common basic workflow for combining local Git development with remote GitHub hosting involves these steps:

1. Create a Repository on GitHub
• Action: Start by creating an empty repository on the GitHub website.


2. Clone the Repository to your local machine (i.e your PC)
• Command: This downloads the remote repository and initializes the local Git environment.

     git clone 'repository-url'



3. Make changes to files in your local working directory.
• Action: Edit, create, or delete files in the project folder.


4. Stage the changes.
• Command: This selects which changes will be included in the next snapshot (commit).

     git add .



5. Commit the changes locally.
• Command: This records the staged changes as a new snapshot in your local history.

     git commit -m "Description of changes"



6. Push the committed changes to GitHub.
• Command: This synchronizes your local history with the remote repository on GitHub, making the changes accessible to others and serving as a crucial remote backup.

     git push origin main

The Synergy: Git and GitHub in Action

• Local Development with Git: You use Git on your local machine to track changes, create commits, and manage branches within your project.


• Pushing to GitHub: Once you've made progress locally, you "push" your local Git repository to a remote repository hosted on GitHub. This makes your changes accessible to others and serves as a crucial remote backup of your work.


• Collaboration via GitHub: Team members can "pull" changes from the GitHub repository to their local machines, make their own modifications, and then "push" them back to GitHub. Pull requests facilitate code review and merging of changes.

Conclusion

In essence, you've learned that Git and GitHub represent the ultimate partnership in modern software development. Git is the robust, local engine — your personal time machine, meticulously tracking every snapshot, branch, and commit. GitHub is the collaborative cloud platform that elevates that engine, providing the critical infrastructure for remote backup, professional code review via Pull Requests, and seamless teamwork.

You now possess the fundamental knowledge required to adopt the standard, collaborative workflow of every professional developer. Mastering the basic cycle — local commits, remote pushes, and managing changes via a remote repository — is the key to working on large projects, contributing to open source, and ensuring you never lose a single line of code again.

Thank you for reading and have a wonderful rest of your day. 👋