Welcome to the show everyone!
I'm Lachlan Reed, here with James Turner, and mates, I have to tell you-I am
absolutely stoked about this.
Imagine you're wrapping up a massive coding session, you're absolutely knackered,
and instead of just getting a list of complaints from your linter,
your terminal actually rolls up its sleeves and fixes the mess for you.
Claude Code just dropped versions 2.1.152 and 154, and they've introduced this
incredible new flag: `/code-review --fix`.
It's not just passive nagging anymore; it's active, direct-to-file edits.
Wait, direct-to-file edits on a code review command?
That is a massive paradigm shift.
Usually, a code review tool just leaves a bunch of comments on your pull request and
lets you do the actual legwork.
Now it's actually writing directly to the workspace?
Spot on, James.
It literally rewrites the files in place.
If it finds a redundant nested loop or a dodgy variable assignment,
it doesn't just tell you "hey, this is trash"-it actually refactors it right there
in your local tree.
And they've doubled down on this with a revamped `/simplify` command,
which is basically a highly targeted, cleanup-only pass of that `/code-review
--fix`.
Ah, so `/simplify` isn't trying to do heavy lifting like hunting down edge-case
logical bugs or security vulnerabilities.
It's literally just a aesthetic and structural pass.
It's looking for things like dead code, overly verbose conditional blocks,
or redundant helper functions and just shaving them down.
Exactly!
It's like having a obsessive-compulsive senior dev hovering over your shoulder,
but instead of annoying you, they just silently clean up your indentation and merge
your nested `if` statements.
But look, there's a catch here.
Since it's writing straight to your disk, you've got to treat these commands like
automated workspace commits.
If you run `/simplify` on a dirty git tree, you are asking for a world of hurt.
Oh, absolutely.
If you don't have a clean working directory before you execute this,
you have zero way to isolate what *you* wrote from what the AI just refactored.
The absolute best practice here has to be: stage your changes,
or commit them, run the command, and then immediately run a `git diff` to inspect
every single line it changed.
You cannot just blind-trust an agent to rewrite your local files without a safety
net.
Too right, mate.
I nearly tanked a client's site years ago by rushing a midnight update,
and let me tell you, checking your diffs is a habit written in blood.
Now, speaking of workflow efficiency, they also added a new `skipLfs` option.
If you're working in massive repositories with heaps of binary assets,
you can skip Large File Storage checks entirely, which makes the whole plugin
management and initialization phase run incredibly fast.
That's actually huge because Git LFS can absolutely crawl when an external tool
starts scanning the tree.
So, by skipping LFS tracking during the analysis phase, Claude Code gets straight to
the source files it actually knows how to edit.
It keeps the feedback loop tight.
It's all about speed and safety, really.
With these direct-to-file edits, we're moving from AI as an advisor to AI as an
active pair programmer.
Just make sure you keep your git history clean, run `/simplify` to sweep up the
cobwebs, and always, always inspect your diffs.
That's our show for today.
Thanks for hanging out with us, and we'll catch you in the next one.
See ya!