Interactive Rebase

Introduction

git rebase -i lets you reorder, squash, edit or drop commits on a branch — the power tool for cleaning up history before a PR lands.

Beginner analogy: think of Git as a "save game" system for your code — every commit is a checkpoint you can revisit, branches are alternate timelines you can explore safely, and a remote like GitHub is the cloud save your whole team can sync with.

In this lesson we will walk through Interactive Rebase step by step, connect the command to Git's internal model, practice a realistic team scenario, and learn the failure modes that matter in production repositories.

Purpose of this lesson

The goal is to make Interactive Rebase operationally useful: you should know when to apply it, which part of Git state it changes, how it affects teammates, and how to recover if the workflow goes wrong.

Understanding the topic

Use this when you need to isolate work, integrate changes safely, or keep a branch current without disrupting teammates. The real skill is not typing the command; it is choosing the history shape that makes review, rollback, and release management easier.

Core concepts to understand:

• Clear definition and mental model of interactive rebase, including which Git layer it changes.
• How the working tree, staging area, local repository, branch refs, and remote refs can differ at the same time.
• How interactive rebase changes review, CI/CD, release notes, rollback, and team coordination.
• Safety nets: reflog, rescue branches, revert, --force-with-lease, and protected branches.
• Risk patterns: rewriting public history, committing secrets, resolving conflicts carelessly, and letting branches drift for weeks.
• Production context: what this looks like in a repository with required reviews, CI gates, release tags, and audit logs.

Visual explanation

Use this architecture view to reason about where the change lives:

Developer Code Changes
        |
        v
Working Directory
        |
        v
git add  ->  Staging Area
        |
        v
git commit -> Local Repository
        |
        v
git push -> Remote Repository
        |
        v
Team Collaboration

Step-by-step explanation

1. Start from a clean working tree and update main with git fetch plus your team's preferred pull or rebase policy.
2. Create a short-lived topic branch with a name that communicates intent, such as feature/payment-retry or fix/null-session.
3. Commit in small reviewable slices; use git diff --staged before each commit to verify the snapshot.
4. Integrate with the target branch using merge or rebase based on team policy, resolving conflicts by preserving behavior rather than blindly choosing one side.
5. Push with an upstream branch, open a PR, let CI validate the result, and delete the branch after merge.

Syntax reference

Visual workflow / architecture:

Developer Code Changes
        |
        v
Working Directory
        |
        v
git add  ->  Staging Area
        |
        v
git commit -> Local Repository
        |
        v
git push -> Remote Repository
        |
        v
Team Collaboration

Informative example

Hands-on commands you can copy-paste:

Rebase rewrites history to look as if you started your branch from the latest main. Use --force-with-lease instead of --force — it refuses to push if a teammate has added new commits.

# Replay your commits on top of latest main
git switch feature/login
git fetch origin
git rebase origin/main

# After resolving any conflicts
git push --force-with-lease

Sample terminal output:

Successfully rebased and updated refs/heads/feature/login.
To github.com:org/repo.git
 + 9a3b1f0...c5e2a44 feature/login -> feature/login (forced update)

Walk-through: notice how Git always prints what changed and where the new state lives — in the working directory, staging area, local .git store, or on the remote. Reading these messages carefully is the difference between a senior Git user and a junior one who fights the tool.

Real-world use

A product team keeps main deployable while several engineers work in parallel. One developer uses Interactive Rebase to isolate a change, explain the intent, verify behavior in CI, and leave behind history that is useful during review, debugging, and release notes.

Enterprise use cases

In an enterprise repository, Interactive Rebase is supported by branch protection, CODEOWNERS, signed commits, required status checks, secret scanning, audit logs, and a documented rollback process. The professional standard is not "I know the command"; it is "the workflow is safe for hundreds of contributors and recoverable during an incident."

Best practices

• Write commit messages in the type(scope): summary Conventional Commits style — feat(auth): add JWT refresh.
• Pull (or rebase) main before starting any new work to avoid painful conflicts later.
• Keep branches short-lived (under 2 days) and pull requests under 400 lines for fast reviews.
• Always use --force-with-lease instead of --force when pushing rewritten history.
• Never commit secrets, build artifacts, .env files or node_modules — add them to .gitignore.

Common mistakes

• Force-pushing to a shared branch — wipes teammates' work and is hard to recover from.
• Committing huge binary files into Git — repository balloons forever; use Git LFS instead.
• Resolving a merge conflict by accepting all of one side without reading the other — silent regressions.
• Working directly on main — bypasses code review and breaks the deployable contract.

Debugging tips

• Before resolving, run git status and git diff --name-only --diff-filter=U to see exactly which files are conflicted.
• Use git log --oneline --left-right --merge during merge conflicts to understand the competing commits.
• If a rebase becomes confusing, git rebase --abort returns you to the pre-rebase state; do that before experimenting blindly.

Optimization strategies

• Make the common path boring: clear branch names, consistent commit messages, protected main, and predictable PR policy.
• Automate checks that humans forget: formatting, secret scanning, tests, signed commits, and branch protection.
• Use Git's safety nets intentionally, especially reflog, revert, and --force-with-lease.

Advanced interview questions

Hands-on exercise

Build a disposable lab for Interactive Rebase. Create a branch, make one intentional change, inspect the diff, commit it, then introduce one realistic mistake and recover. The exercise is complete only when you can explain which layer changed: working tree, index, local branch, remote branch, or object database.

Suggested lab directory: git-interactive-rebase-lab.

mkdir git-interactive-rebase-lab
cd git-interactive-rebase-lab
git init
git switch -c practice/interactive-rebase
echo "first change" > notes.txt
git status -sb
git add notes.txt
git commit -m "practice: explore interactive-rebase"
git log --oneline --graph --decorate --all

Summary

Interactive Rebase is valuable when it makes history easier to understand, collaboration safer, and recovery faster. Treat Git as both a local database and a team operating system: inspect state before changing it, keep history useful, and automate the rules that protect production.