Git UNDO : How to Rewrite Git History with Confidence

2026-04-21 · Source: Towards Data Science · Field: Technology & Digital — Software Development & Engineering · Depth: Intermediate, extended

Summary

This article details how to confidently rewrite Git history by understanding its internal mechanisms and utilizing key commands. It begins by explaining Git's three states: the working directory, the index (staging area), and the repository, illustrating how changes are recorded through `git add` and `git commit`. The core of the article focuses on `git reset` with its `--soft`, `--mixed`, and `--hard` options, demonstrating how each option progressively undoes commits, staging, and working directory changes. It also introduces `git cherry-pick` for applying specific commit changes to another branch and `git revert` for safely undoing pushed commits by creating a new "undo" commit. Finally, the `git reflog` command is presented as a crucial tool for recovering lost commits, even after a `git reset --hard`, by tracking HEAD's past positions.

Key takeaway

For Data Scientists and Software Engineers managing Git repositories, understanding the nuanced effects of `git reset`'s `--soft`, `--mixed`, and `--hard` options is crucial for precise history manipulation. Before executing any complex undo operation, visualize the current and desired repository states. This practice, combined with knowing when to use `git revert` for public history and `git reflog` for recovery, will prevent data loss and streamline collaborative development workflows.

Key insights

Mastering Git's internal states and undo commands enables confident history rewriting and recovery.

Principles

• Git tracks filesystem snapshots across three states.
• A branch is a named reference to a commit.
• Whiteboarding current vs. desired states clarifies Git operations.

Method

To undo Git changes, use `git reset --soft` to undo commits, `--mixed` to also undo staging, and `--hard` to additionally undo working directory changes. For pushed commits, `git revert` creates a new undo commit. Recover lost commits via `git reflog`.

In practice

• Use `git reset --mixed HEAD~1` to uncommit and unstage the last commit.
• Employ `git cherry-pick <SHA-1>` to apply specific changes to another branch.
• Consult `git reflog` or `git log -g` to recover seemingly lost commits.

Topics

• Git History Rewriting
• Git Reset Command
• Git Cherry-Pick
• Git Revert Command
• Git Reflog

Best for: Data Scientist, Software Engineer, Machine Learning Engineer

Related on AIssential

• Using Git with coding agents — Coding agents significantly enhance Git workflows, simplifying complex operations and enabling advanced version control practices.
• Dropbox Collaborates with GitHub to Reduce Monorepo Size from 87GB to 20GB — Dropbox engineers, in collaboration with GitHub, successfully reduced their backend monorepo size from 87GB to 20GB, significantly improving developer productivity and continuous integration performance.
• Enhancing Software Maintenance: A Learning to Rank Approach for Co-changed Method Identification — Learning-to-rank models effectively predict co-changed methods by combining static and historical code features at the pull-request level.
• v2.1.114 — A changelog provides a transparent, version-controlled history of project modifications.
• GitHub Repo Stats — GitHub Repo Stats offers detailed repository metrics via the GitHub REST API, enhancing mobile site functionality.
• I Deleted 4TB of Production Data by Trusting dbt’s --full-refresh Flag — Misunderstanding a command's full implications can lead to catastrophic data loss, especially without validated backups.

Open in AIssential →

Editorial summary, takeaway, and curation by AIssential. Original article published by Towards Data Science.