git commit

Seal the index into a permanent commit object.

git commit

What it does

git commit reads the index, wraps it in a tree object, and creates a commit object that points to that tree and to your current HEAD. Then it moves the branch ref forward. The commit is immutable and permanent — this is history being written.

The commit object is appended and the branch pointer slides forward

Watch it — press play

A narrated, step-by-step walkthrough that shows how to do it — not just theory. It adapts to the learner mode you picked in the top bar.

1 / 3

Step 1

Stage first

Before a commit, files live in the index (staging). The index is a preview of what the commit will contain.

git add .

Working Tree

files on disk

src/button.tsxM

src/theme.cssM

filtered in the index

Index · Staging

.git/index

src/button.tsxA

src/theme.cssA

snapshot copied in

Repository

objects/ → commits

committed history

The index holds your next snapshot

Under the hood

Step 1 — a tree is built from the index

Every staged path is packaged into trees (directories) and blobs (files). The top-level tree object describes the entire project snapshot.

tree f2b0c9d…
├─ blob aa8f1e…  README.md
├─ blob 3c2d09…  src/main.ts
└─ tree b7e1a2…  src/

Step 2 — the commit object is written

Git builds a commit object containing the tree hash, the parent commit hash(es), the author, the committer, and your message — then hashes THAT. This hash is the commit's identity.

commit 74d3b9f  (your new commit)
  tree    f2b0c9d…
  parent  9a2f1c0…  (previous commit)
  author  Ada <ada@…>
  committer Ada <ada@…>
  message feat: add dark mode

Step 3 — the branch moves, HEAD follows

The branch file you're on (refs/heads/main) is rewritten to contain the new commit hash, and HEAD points at that branch. The commit is now 'on' the branch.

git rev-parse main   # → 74d3b9f…
cat .git/HEAD         # → ref: refs/heads/main
cat .git/refs/heads/main  # → 74d3b9f…

Why parent pointers make history

Every commit records its parent. Following the chain of parents from any commit walks the entire history. This is exactly what git log does — it is nothing but a linked list traversal.

Command anatomy

git commit -m "<message>"

-m

Set the commit message inline.

-a

Stage all tracked modified files before committing (never new files).

--amend

Replace the last commit — new tree, new message, new hash.

--no-verify

Skip pre-commit and commit-msg hooks.

When to reach for it

A logical unit of work is finished and the index looks right.

You fixed a typo in the last commit: git commit --amend --no-edit.

Combining with -a when you're committing everything and the index dance is overhead.

Practice

A real repo, pre-seeded with history, runs right here — stage, commit, branch, stash, diff, even hit and resolve a real merge conflict. Nothing to install, nothing leaves your machine.

Open practice playground

Go deeper with

git add

Copy your edits into the staging area (the index).

git status

Compare the working tree, the index, and the last commit.

git log

Walk the chain of parent links and read your history.

git reset

Move the branch pointer and undo your staging decisions.