Throwing Work Away Cheaply

There are three ways back, and which one applies depends on where the work is. Uncommitted changes are discarded, private commits are reset, shared commits are reverted. Each takes seconds. What stops people from using them is not git but the forty minutes already spent.

Chapter 6 decided when to reject a diff. This page is the mechanics, and the one argument that keeps engineers polishing a wrong approach long after a restart would have been cheaper.

Uncommitted: Discard

When the agent's attempt was never committed, restore the tracked files to the last commit, then remove the untracked files the agent created, after a dry run that shows what would go. The agent's whole attempt is gone, and the base commit you made before asking is untouched.

$ git restore .
$ git clean -n
Would remove notes.md
Would remove src/cragmoor/policy.py
$ git clean -f src
Removing src/cragmoor/policy.py
$ git status --short
?? notes.md

$ git restore .
$ git clean -n
Would remove notes.md
Would remove src/policy.ts
$ git clean -f src
Removing src/policy.ts
$ git status --short
?? notes.md

$ git restore .
$ git clean -n
Would remove notes.md
Would remove src/main/java/org/cragmoor/Policy.java
$ git clean -f src
Removing src/main/java/org/cragmoor/Policy.java
$ git status --short
?? notes.md

The dry run is the step that earns its keep. It listed your notes file next to the agent's new file, so the real cleanup was narrowed to the directory the agent worked in, and the notes survived.

A cleanup scoped to a path is the habit worth keeping. The unscoped form removes every untracked file under the current directory, and in a working repository that includes scratch scripts, exported data and half-written notes that were never meant to be committed. The agent's files are almost always inside the source directories it was asked to work in, so name those directories and leave the rest alone.

Committed, Not Shared: Reset

When the agent's commits sit on a branch only you have, move the branch back to the last good commit. The agent's commits leave the branch, and nobody else is affected, because nobody else has them. This is the right tool for a private branch and the wrong one for anything already pushed.

$ git log --oneline -3
18d71bd (HEAD -> refund-window-12h-attempt) wip: agent attempt, deadline helper
8ebba91 Refund diff as the agent delivered it
2941125 (refund-window-12h) Use one refund window for refunds and the cancellation screen
$ git reset --hard refund-window-12h
HEAD is now at 2941125 Use one refund window for refunds and the cancellation screen

$ git reflog -2
2941125 (HEAD -> refund-window-12h-attempt, refund-window-12h) HEAD@{0}: reset: moving to refund-window-12h
18d71bd HEAD@{1}: commit: wip: agent attempt, deadline helper

The log shows the agent's two commits on top of the refund branch's last good commit, and the reset moves the attempt branch back to that commit in one step. The commits are not destroyed: the reflog still records where the branch pointed a moment ago, which is what makes a reset on a private branch safe to try.

Shared: Revert

Once a commit is pushed or merged, history is shared. Others have built on it, or at least fetched it. A reset there rewrites what they already have, and their next pull either fails or quietly brings the commit back. A revert adds a new commit that undoes the old one, so everyone's history stays intact and the undo itself is reviewable.

A revert is a change like any other, and it gets a message that says why: "Revert the 12-hour refund window: the operations decision is postponed to next month." It goes through review, it runs the tests, and it can itself be reverted when the decision comes back. That is the property that makes shared history safe to undo: nothing disappears, and every step is explained.

Keeping Half

Narrowing, from Chapter 6, in git terms: stage the hunks you accept, commit them, then discard the rest. Or, when the agent committed in steps, keep the commits you accepted and reset past the ones you did not. Either way the result is a branch that holds exactly the part of the answer you read and agreed with, and nothing that arrived alongside it.

The Sunk-Cost Trap

Forty minutes of redirects on one diff, the figure this page uses, feel like an investment. The honest comparison is the next ten minutes. One option is another redirect into a context full of failed attempts, which Chapter 4 showed makes each answer worse. The other is a fresh session from the base commit with a task that carries the lesson: "compute the deadline in the gym's time zone; do not edit tests; no new types".

The lesson lives in the task, not in the code. Nothing in the forty minutes of diffs is worth keeping except what they revealed about the problem, and that fits in one sentence of the new task. Restarting throws away the code of a wrong approach and keeps everything learned from it.

The trap has a recognisable feel. The redirects get longer, each one adds a constraint the previous answer broke, and the diffs start to undo each other. When a third message repeats a point the first one already made, the session has stopped converging. Stop there, write the constraints down, discard, and start again. Chapter 10 applies the same rule to a debugging session that goes in circles.

The Net Under the Net

A reset that went too far can be undone. The reflog records where each branch and HEAD pointed, move by move, so the commits a reset left behind can be found and restored. Committed work is very hard to lose in git.

Uncommitted work is different. The reflog records the movements of references, not the contents of your working tree, so it cannot bring back changes discarded before they were committed, and edits that were never staged are gone for good. That is one more reason for the commit before every request: it turns everything into the kind of work git can bring back. The reflog itself is covered in Git, GitHub & GitHub Actions, Topic 18.