HomeTerminal & Command LineGit Basics — init, add, commit, push
beginner12 min read· Module 3, Lesson 10

📌Git Basics — init, add, commit, push

Your first commits — hands-on practice from zero

Git Basics — init, add, commit, push

Welcome to your first hands-on Git lesson. By the end of this tutorial, you will have created a real repository, made commits, and pushed your code to GitHub. Every step includes the exact command to run and what to expect.

Why Git Matters

Git is the version control system used by virtually every software team in the world. It tracks every change you make, lets you undo mistakes, collaborate with others, and maintain a complete history of your project. Without Git, you are flying blind.

Step 1 — Create a Project Folder

Open your terminal and create a new folder for your project:

Terminal
mkdir my-first-project cd my-first-project

You now have an empty folder. Git does not know about it yet.

Step 2 — Initialize a Git Repository

Run the following command inside your project folder:

Terminal
git init

What happens: Git creates a hidden .git folder inside your project. This folder contains the entire history database. You never need to touch it directly.

Expected output:

Initialized empty Git repository in /path/to/my-first-project/.git/

Step 3 — Check the Status

Terminal
git status

Understanding the output:

On branch main No commits yet nothing to commit (create/copy files and use "git add" to track)

This tells you three things:

  1. You are on the main branch (the default branch).
  2. There are no commits yet — the history is empty.
  3. There are no files to track — the folder is empty.

Key insight: git status is your best friend. Run it constantly. It always tells you exactly where you stand.

Step 4 — Create Your First File

Terminal
echo "# My First Project" > README.md

Now run git status again:

On branch main No commits yet Untracked files: (use "git add <file>..." to include in what will be committed) README.md nothing added to commit but untracked files present

Untracked means Git sees the file but is not watching it yet. You must explicitly tell Git to track it.

Step 5 — The Staging Area (git add)

This is the most misunderstood concept for beginners. Git has a staging area (also called the index). Think of it as a loading dock:

Working Directory → Staging Area → Repository (your files) (ready to ship) (permanent history)

To move a file to the staging area:

Terminal
git add README.md

Now check the status:

Terminal
git status
On branch main No commits yet Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: README.md

The file is now staged — it is ready to be committed. The green text (in your terminal) confirms this.

Adding Multiple Files

Terminal
git add file1.txt file2.txt # Add specific files git add . # Add everything in current directory git add *.js # Add all JavaScript files

Warning: git add . adds everything. Be careful — you might accidentally stage files you do not want (passwords, large binaries, etc.). That is why .gitignore exists (covered below).

Step 6 — See What Changed (git diff)

Before committing, you can see exactly what changed:

Terminal
git diff # Shows unstaged changes git diff --staged # Shows staged changes (what will be committed)

Example output:

DIFF
diff --git a/README.md b/README.md new file mode 100644 index 0000000..4b5fa63 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# My First Project

Lines starting with + are additions. Lines starting with - are deletions. This is how you review your work before saving it permanently.

Step 7 — Make Your First Commit

Terminal
git commit -m "Initial commit: add README"

What happens: Git takes a snapshot of everything in the staging area and saves it permanently with your message, your name, a timestamp, and a unique ID (hash).

Expected output:

[main (root-commit) a1b2c3d] Initial commit: add README 1 file changed, 1 insertion(+) create mode 100644 README.md

Commit message best practices:

  • Use present tense: "Add feature" not "Added feature"
  • Be specific: "Fix login timeout on slow networks" not "Fix bug"
  • Keep the first line under 72 characters
  • If you need more detail, leave a blank line then write a paragraph

Step 8 — View Your History (git log)

Terminal
git log
commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0 (HEAD -> main) Author: Your Name <your@email.com> Date: Fri Apr 25 2026 10:00:00 Initial commit: add README

Every commit has:

  • A hash (the long hex string) — a unique fingerprint
  • The author — who made the change
  • The date — when
  • The message — why

Step 9 — Modify, Stage, Commit Again

Edit your file:

Terminal
echo "This project demonstrates Git basics." >> README.md

Check what changed:

Terminal
git status git diff

Stage and commit:

Terminal
git add README.md git commit -m "Add project description to README"

Step 10 — Compact History View

Terminal
git log --oneline
b2c3d4e Add project description to README a1b2c3d Initial commit: add README

This is the compact view — one line per commit. Much easier to scan. Other useful variations:

Terminal
git log --oneline --graph # Shows branch structure visually git log --oneline -5 # Shows only last 5 commits git log --oneline --all # Shows all branches

Step 11 — Create a .gitignore File

Some files should never be committed: passwords, API keys, build artifacts, OS files. Create a .gitignore file:

Terminal
touch .gitignore

Add patterns to it:

# Dependencies node_modules/ # Environment variables (NEVER commit these) .env .env.local # Build output dist/ build/ # OS files .DS_Store Thumbs.db # IDE files .vscode/ .idea/ # Logs *.log

Stage and commit:

Terminal
git add .gitignore git commit -m "Add .gitignore for common exclusions"

Important: .gitignore only prevents untracked files from being added. If you already committed a file and then add it to .gitignore, it will still be tracked. You must remove it first:

Terminal
git rm --cached .env # Stop tracking but keep the file locally git commit -m "Remove .env from tracking"

Step 12 — Create a GitHub Account

  1. Go to https://github.com
  2. Click Sign up and follow the steps
  3. Verify your email address
  4. You now have a place to store your code online

On GitHub, click New repository:

  • Name: my-first-project
  • Keep it public (or private, your choice)
  • Do NOT initialize with README (you already have one)
  • Click Create repository

GitHub will show you setup instructions. Follow the ones below.

Step 13 — Connect to GitHub (git remote)

Terminal
git remote add origin https://github.com/YOUR-USERNAME/my-first-project.git

What this does: It tells your local Git that there is a remote server called origin at that URL. The name origin is a convention — it means "the main remote."

Verify it worked:

Terminal
git remote -v
origin https://github.com/YOUR-USERNAME/my-first-project.git (fetch) origin https://github.com/YOUR-USERNAME/my-first-project.git (push)

Step 14 — Push Your Code

Terminal
git push -u origin main

Breakdown:

  • git push — send commits to the remote
  • -u — set upstream tracking (so next time you can just type git push)
  • origin — the remote name
  • main — the branch name

After this, refresh your GitHub page. Your files and commit history are now online.

For future pushes, you only need:

Terminal
git push

Step 15 — Pull Changes

If someone else pushes changes (or you edit on GitHub directly), pull them down:

Terminal
git pull

This fetches the latest commits from the remote and merges them into your local branch. Always pull before you start working to avoid conflicts.

Step 16 — Clone an Existing Repository

To download someone else's project (or your own on a new computer):

Terminal
git clone https://github.com/username/repository-name.git

This creates a new folder with the project name, downloads all files and history, and automatically sets up the remote.

Terminal
git clone https://github.com/username/repo.git my-folder # Custom folder name

The Full Workflow Diagram

Here is the complete Git workflow you will use daily:

┌──────────────┐ git add ┌──────────────┐ git commit ┌──────────────┐ git push ┌──────────────┐ │ Working │ ──────────────→ │ Staging │ ───────────────→ │ Local │ ─────────────→ │ Remote │ │ Directory │ │ Area │ │ Repository │ │ Repository │ │ (your edits)│ │ (index) │ │ (.git) │ │ (GitHub) │ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ ↑ │ └─────────────────────────────────── git pull ────────────────────────────────────────────────────┘

The daily cycle:

  1. git pull — get latest changes
  2. Edit your files
  3. git add — stage changes
  4. git diff --staged — review
  5. git commit -m "message" — save snapshot
  6. git push — share with team

Common Mistakes and How to Fix Them

Mistake 1: Forgot to add a file before committing

Terminal
# You committed but forgot a file git add forgotten-file.txt git commit -m "Add forgotten file"

Or, if you want to include it in the previous commit:

Terminal
git add forgotten-file.txt git commit --amend --no-edit # Adds to the last commit without changing the message

Warning: Only amend commits that have NOT been pushed yet.

Mistake 2: Wrong commit message

Terminal
git commit --amend -m "Correct commit message here"

Again, only do this before pushing.

Mistake 3: Push rejected (remote has changes you do not have)

! [rejected] main -> main (non-fast-forward)

Fix:

Terminal
git pull --rebase origin main # Pull and replay your commits on top git push

Mistake 4: Accidentally staged a file

Terminal
git reset HEAD secret-file.env # Unstage without deleting

Or with newer Git:

Terminal
git restore --staged secret-file.env

Mistake 5: Want to undo the last commit (keep changes)

Terminal
git reset --soft HEAD~1 # Undo commit, keep files staged

Commands Cheatsheet

CommandWhat It Does
git initInitialize a new repository
git statusShow current state of working directory and staging area
git add <file>Stage a file for the next commit
git add .Stage all changed files
git diffShow unstaged changes
git diff --stagedShow staged changes
git commit -m "msg"Create a commit with a message
git commit --amendModify the last commit
git logShow full commit history
git log --onelineShow compact commit history
git remote add origin <url>Connect to a remote repository
git push -u origin mainPush and set upstream tracking
git pushPush commits to remote
git pullFetch and merge remote changes
git clone <url>Download a repository
git rm --cached <file>Stop tracking a file
git reset HEAD <file>Unstage a file
git restore --staged <file>Unstage a file (modern syntax)
git reset --soft HEAD~1Undo last commit, keep changes staged

Practice Exercises

Exercise 1 — Full Cycle

  1. Create a new folder called practice-git
  2. Initialize it as a Git repository
  3. Create a file called hello.txt with the text "Hello, Git!"
  4. Stage and commit the file
  5. Modify the file to add a second line
  6. Check the diff, then stage and commit
  7. View the log in oneline format

Exercise 2 — .gitignore

  1. In the same repository, create a file called secrets.env
  2. Create a .gitignore file that excludes *.env files
  3. Run git status — verify secrets.env does not appear
  4. Stage and commit the .gitignore

Exercise 3 — Push to GitHub

  1. Create a new repository on GitHub (do not initialize with README)
  2. Add the remote to your local repository
  3. Push your commits
  4. Verify on GitHub that all files and history are visible

Exercise 4 — Clone and Modify

  1. Clone your repository to a different folder
  2. Make a change in the cloned copy
  3. Commit and push from the clone
  4. Go back to the original folder and pull the changes

Key Takeaways

  1. git init creates a repository — do this once per project
  2. git add moves files to the staging area — you choose what to commit
  3. git commit saves a permanent snapshot — always write a clear message
  4. git push shares your work — sends commits to the remote
  5. git pull stays in sync — always pull before starting work
  6. git status and git diff are your safety net — use them constantly
  7. .gitignore protects sensitive files — set it up early
  8. Never commit secrets, large binaries, or build artifacts

You now have all the fundamentals. Every advanced Git concept (branches, merges, rebases, pull requests) builds on exactly these commands.

Module 3
10/11
Previous
🔀 What is Git? (Version Control)
Next
GitHub — Your Code in the Cloud 🐙
Previous
10/11
Next