Learn Git - Interactive Rebase & History Cleanup

#Introduction

In the previous episode 15 we tidied the working directory: storing unfinished work with git stash and cleaning untracked files with git clean. In episode 16 we go up one level and tidy something far more valuable: the commit history itself, through Interactive Rebase.

Why does this matter? Commit history is documentation read by the entire team. A messy history — fix typo, wip, test again, asdf — makes code review, debugging, and regression tracking painful. Interactive rebase gives you full control to reshape history before code goes to the remote, exactly like editing a draft before it is published.

#The Rebase Concept (Quick Recap)

We touched basic rebase in episode 7 when comparing merge vs rebase. In essence: rebase reapplies commits on top of a new base so history becomes linear. Because commits are reapplied, every commit produces a new SHA — a rebased history is never identical to the original. Interactive mode just adds one feature: you can intervene in the middle of the process. Make sure you are using a recent Git with git --version (stable version 2.4x in 2026).

#Starting an Interactive Rebase

git rebase -i HEAD~3

The command above opens an editor containing the last three commits, ordered from the oldest at the top line to the newest at the bottom:

pick a1b2c3d feat: tambah model User
pick e4f5g6h fix: perbaiki validasi email
pick i7j8k9l chore: rapikan dokumentasi

This is called the todo list. You are free to rearrange the lines, then save — Git executes the commands one by one from top to bottom.

#Commands in Interactive Rebase

#reword: Changing a Commit Message

Change pick to reword (or r) on the line of the commit whose message you want to change. After the todo is saved, a new editor opens to type the final message. Result: the commit content stays, the SHA and message change.

#squash: Combining Commits Along with Their Messages

Three small commits that should have been one can be unified:

pick a1b2c3d feat: tambah model User
squash e4f5g6h fix: perbaiki validasi email
squash i7j8k9l chore: rapikan dokumentasi

After the todo is saved, Git opens a second editor to compose the combined message. Save, and the three commits become one:

git log --oneline

The order in the todo list matters a lot: squash always attaches to the commit on the line above it (the older one). So arrange the lines in chronological order, not a random order.

#fixup: Combining Without the Noise

fixup is identical to squash, but the message of the fixup commit is discarded without showing the message-combining editor:

pick a1b2c3d feat: tambah model User
fixup e4f5g6h typo kecil

The end result is a single clean commit feat: tambah model User — ideal for small corrections that do not deserve their own commit.

#drop: Deleting a Commit

Change to drop (or d) to delete a commit from history. This is a cleaner option than leaving a wrong commit on a shared branch.

#Aborting a Rebase Session

If you realize something is wrong mid-session, or you simply want to back out:

git rebase --abort

The session is cancelled and history returns to exactly what it was before the rebase began.

#The Golden Rule of Rebase

There is one non-negotiable rule:

Never rebase a branch that has been published and is shared with other people.

Rebase rewrites commit SHAs. If main on the remote is used by many people, rewriting its history makes everyone's repository out of sync — like changing a house address already printed on thousands of business cards.

#Pushing Again After a Rebase

A feature branch that was pushed and then rebased will be rejected by the remote because the history differs. The solution is a safe force push:

git push --force-with-lease origin nama-branch

--force-with-lease checks the remote state before overwriting: if someone else has added commits to that branch, the push is rejected. Far safer than a bare git push --force.

#Closing

The points to take with you:

• git rebase -i HEAD~N opens a todo list to tidy up the last N commits.
• reword changes a message, squash combines commits along with their messages, fixup combines without messages, and drop deletes a commit.
• The todo list is processed top to bottom; squash and fixup attach to the commit on the line above.
• Golden Rule: never rebase a shared public branch.
• Force push only with --force-with-lease, and only for your own history.

Now that you can reshape history, you need tools to navigate it intelligently. In the next episode 17 we cover Advanced History Navigation: taking a specific commit from another branch with git cherry-pick, recovering deleted commits through git reflog, and finding the commit that caused a bug with git bisect. See you in episode 17!