The Real Reason People Stay Cautious With AI Agents
It's not that they don't trust the model. It's that file changes feel permanent. You ask the agent to refactor a function, it rewrites three files, and somewhere in there it quietly breaks something you didn't even ask it to touch. By the time you notice, your mental diff of "what changed" is already gone.
So people work around it. They duplicate files before running the agent. They commit to git first. They run the agent on small, surgical prompts instead of the bigger task they actually want done. All of that friction is a tax on the tool.
lac agent has a proper undo/redo system, and it fixes this. I'm embarrassed it took me a few weeks of daily use before I leaned on it properly.
How the Undo Stack Works
Every time lac agent writes to a file, it snapshots the previous state before touching anything. That snapshot goes onto an undo stack. If the agent touches five files in one response, all five snapshots are grouped together as a single undo entry. You undo the whole operation at once, not file by file.
To step back, just type /undo inside the agent session. It rolls every file in that last operation back to what it was before the agent touched it. No git required, no manual backup needed.
/redo does the reverse — if you undid something and changed your mind, it reapplies the changes.
The stack isn't shallow either. It tracks your entire session, so if the agent makes three rounds of edits and all three go sideways, you can /undo three times and land back at your starting point.
Diff Preview Before You Commit
The part I use even more than undo is the diff preview. Before lac agent actually writes a change, it shows you exactly what it's about to do — a clean before/after diff, file by file. You see additions in green, removals in red, the file path at the top of each block.
You can review the full diff and then decide. Accept it, reject it, or ask the agent to revise before anything touches disk. This is what PlanMode is for code planning — diff preview is for file writes specifically.
The workflow I've settled into: I let the agent run with a fairly broad prompt, I read the diff when it comes back, I spot anything that looks wrong, and I either ask for a revision or accept. If I accept and then notice something broken at runtime, /undo gets me back in under a second.
It sounds obvious written out. But it genuinely changes how you prompt. You stop padding every request with qualifiers like "only touch the auth module" and "don't change the config file" because you know you can review and roll back. You just ask for what you want.
A Concrete Example
Say I'm working on a Node project and I want the agent to extract a utility function that's scattered across four different files into a shared module and update all the import paths.
Before, I'd probably do this manually or write a very careful, narrow prompt. Now I just open the agent:
lac agent
And ask it directly:
"Extract the formatDate helper — it appears in routes/users.js, routes/posts.js, middleware/logger.js, and utils/export.js — into a new shared/dates.js module. Update all the import paths."
The agent reads the files, writes the plan, and shows me a diff across all five affected files (four updates plus the new module). I check that formatDate landed correctly in shared/dates.js, that the imports look right, that it didn't accidentally pull in anything else. I accept. Done.
If the import paths are wrong or it missed one, I type /undo, correct my prompt, and run it again. The whole loop takes less time than doing the refactor by hand would have.
What Happens to .lac-memory.json
One thing worth knowing: undo affects the files the agent wrote to, not .lac-memory.json. Project memory is a separate concern and isn't rolled back on undo. If the agent updated your memory file with something inaccurate during a session you're undoing, you may want to check that file manually and clean it up. It's usually fine, but it's good to know what's in scope.
This Is Why I Don't Commit Before Every Agent Session Anymore
I used to do a quick git add . && git commit -m "pre-agent checkpoint" before any session where I expected the agent to touch multiple files. It felt responsible. It also added a bunch of noise to my commit history.
Now I just run the agent, use the diff preview, and keep /undo in my back pocket. If I'm wrapping up a big session and everything looks good, that's when I commit — one clean commit that represents the actual work, not a mix of my code and safety checkpoints.
Git is still useful for the longer history and collaboration. But for the within-session safety net, the undo stack handles it better.
Try It Today
If you haven't used /undo in a lac agent session yet, the fastest way to get comfortable with it is deliberately. Run the agent on something small, let it make a change, then type /undo and watch it roll back. Once you see it work, you'll stop treating agent edits like they're irreversible.
Install or update lac-cli with:
pip install --upgrade lac-cli
Then start a session in any project directory with lac agent, make a change, and try the diff preview and undo flow. You can read more about what lac-cli can do over at the lac-cli page.
The safety net is already there. You just have to know to use it.