You finish a change, the linter lights up, and you're back in the diff fixing the same three classes of problem you always fix. /simplify collapses that loop: instead of a report, it edits the files for you.
What /simplify Does to Your Diff
/simplify is a post-implementation cleanup-and-review pass bundled into Claude Code that reads only the files in your current diff, fans out parallel review agents over those changes, and applies fixes in place rather than annotating them . That last part is the core distinction from a lint report: the file is changed, not flagged. Scanning the diff instead of the whole codebase also keeps scope tight and token cost low.
As originally shipped, it ran three agents concurrently over your changed files :
- Reuse — finds duplicated logic and surfaces existing utilities that could replace the new code you just wrote.
- Quality — flags readability, structure, redundant state, and leaky abstractions.
- Efficiency — catches unnecessary work, missed concurrency, and hot-path bloat.
The skill has kept tightening. In v2.1.160 (June 2, 2026), the workflow merged five cleanup finders into one, cutting token usage by roughly 25% per invocation . So the same review runs cheaper than it did at launch — worth knowing before you wire it into every PR.
The reason to treat this as an every-project habit rather than a novelty comes from first-party attribution. On February 27–28, 2026, Boris Cherny — the Anthropic member of technical staff who created Claude Code — announced on Threads and X that the next version would ship /simplify and /batch, and said he had "been using both daily" .
"Been using both [/simplify and /batch] daily." — Boris Cherny, member of technical staff at Anthropic (source: Threads)
Because the skill is bundled — auto-installed and present in every session on every codebase — that daily habit needs no per-repo setup to reproduce .
Putting /simplify Into Your PR Habit
To reproduce Cherny's habit, run /simplify as the last step before you open a pull request: draft your change, invoke the skill, review the edits it applied to your working tree, then commit. The skill is bundled, so there is no .claude/skills/ folder to create and no install step — it ships in Claude Code and is available in every session . Here is the minimal copy-paste path.
Step 1 — Confirm your version. The /simplify and /batch skills landed as bundled commands in Claude Code v2.1.63 . Check what you are running:
claude --version
# or, inside a session:
/versionIf you are on v2.1.63 or later, the skill is already present — nothing else to install.
Step 2 — Draft first, then simplify. After you finish writing your feature or fix, type /simplify with no arguments. It locates the diff automatically, looking only at the files you changed, so you do not pass a path . It fans out parallel review agents over those diffs and applies fixes directly rather than only reporting them .
Step 3 — Review, then commit. Inspect the applied edits in your working tree. Stage them as a separate cleanup commit if you want a clear audit trail, or squash them into the feature commit before pushing.
Step 4 (optional) — Re-run after a rebase. If a merge or rebase pulls in new diff files, invoke /simplify again so the cleanup pass covers the additional changes.
Scoped shortcut. To narrow the pass to one concern, append a focus clause instead of running the full review:
/simplify focus on error handling
/simplify focus on memory efficiencyThis limits the agents to a single dimension — useful on a hot path where you only care about efficiency, or on I/O code where error handling is the risk .
The Rename: /simplify Is Now a Wrapper
If you follow the changelog, you'll notice /simplify and /code-review are the same evolving skill, not two tools. In v2.1.147 (May 21, 2026), /simplify was renamed to /code-review; its behavior shifted toward reporting correctness bugs at a selectable effort level (for example, /code-review high), and the original auto-apply cleanup behavior was removed . That broke the muscle memory of anyone who expected fixes applied in place, so in v2.1.152 (May 27, 2026) /simplify returned as a thin wrapper that calls /code-review --fix internally, restoring the apply-to-working-tree behavior most people relied on . Then in v2.1.160 (June 2, 2026), the workflow merged five cleanup finders into one, cutting token usage roughly 25% per invocation .
The practical split today: /simplify applies edits to your working tree; /code-review alone reports findings without touching files; and /code-review --comment posts findings as inline GitHub PR annotations . Pick the verb that matches your intent — fix, report, or annotate.
| Version | Date | Behavior change | Net effect on /simplify |
|---|---|---|---|
| v2.1.147 | 2026-05-21 | Renamed to /code-review; reports correctness bugs at effort levels; auto-apply removed | Fix-in-place gone |
| v2.1.152 | 2026-05-27 | /simplify reinstated, calling /code-review --fix internally | Apply-in-place restored |
| v2.1.160 | 2026-06-02 | Five cleanup finders merged into one | ~25% fewer tokens per run |
Where to Push /simplify Further
Once the default pass is part of your habit, three knobs make it sharper. First, scope it to one dimension so only the relevant agent fires: /simplify focus on memory efficiency or /simplify focus on error handling narrows the review instead of running the full reuse/quality/efficiency sweep (source: howborisusesclaudecode.com).
Second, when you want reviewer-visible notes rather than auto-applied edits, use /code-review --comment. The --comment flag posts findings as inline GitHub PR annotations without touching the working tree, added in v2.1.147 (2026-05-21) (source: Claude Code changelog). It leaves the fix decision to the human reviewer.
Third, let /batch carry the habit at fleet scale. Each /batch worker runs in its own git worktree and automatically runs /simplify on its diff before committing, so every generated PR gets the cleanup pass with no extra invocation (source: claudefa.st).
The combination pattern ties it together: decompose a large refactor with /batch, then layer /code-review --comment on each batch PR for a reviewer-ready annotation pass. Start narrow with a focus flag on your next change, then scale the same discipline across a migration.
Watch / Sources
- Anthropic — Mastering Claude Code in 30 minutes
- Matt Pocock — 5 Claude Code skills I use every single day
- Greg Isenberg — Claude Code Clearly Explained (and how to use it)
Frequently asked questions
Is /simplify the same as /code-review in Claude Code?
They are one evolving skill, not two tools. Since v2.1.152 (May 27, 2026) /simplify is a thin wrapper that invokes /code-review --fix, applying findings directly to your working tree . Type /simplify to auto-apply edits in place; type /code-review alone to report findings without touching your files.
Does /simplify require any setup or configuration before it works?
No. It ships as a bundled (auto-installed) skill in Claude Code from v2.1.63 onward — there is no .claude/skills/ folder to author and no install step . Because it is bundled rather than checked into a single repo, it is present in every session on every codebase on qualifying versions.
What does /simplify catch that a linter misses?
It reasons about structure and design, not just style. As originally shipped it fanned out three parallel agents over your diff: a Reuse agent that surfaces existing utilities to replace duplicated logic, a Quality agent flagging leaky abstractions and redundant state, and an Efficiency agent catching missed concurrency and hot-path bloat . Linters target syntax and formatting; /simplify targets design.
How do I limit /simplify to one type of concern instead of the full pass?
Append a focus phrase to scope the run: /simplify focus on memory efficiency or /simplify focus on error handling . This narrows the cleanup pass to the relevant dimension and skips the others, which is useful for a targeted review or when token budget matters.
How does /batch relate to /simplify?
Each /batch worker automatically runs /simplify on its own diff before committing. /batch decomposes a large task into roughly 5–30 independent units, spawns one background agent per unit in an isolated git worktree, and opens a PR for each . The upshot: every generated PR arrives with the cleanup pass already applied.
