Boris Cherny, the creator of Claude Code, announced two new built-in skills shipping in the next version: /simplify and /batch. Both use parallel agents under the hood, but they solve completely different problems -- and understanding that difference determines whether you get a 30-second quality pass or a week's worth of migration work done before lunch.
What /simplify Actually Does
/simplify spins up parallel agents after you make a code change and has them focus on three things:
- Code quality improvements
- Efficiency tuning
- CLAUDE.md compliance checking
The intended usage is dead simple: make your change, then tell Claude to run it. Something like "hey claude update the auth middleware then run /simplify" -- and from there it handles the review loop that used to require either a careful second read or a PR comment from a teammate.
Before /simplify: You write the change, maybe run a linter, commit, push, and hope reviewers catch anything subtle you missed. The feedback cycle might be hours.
After /simplify: Parallel agents review the change immediately, surfacing quality and compliance issues before the commit ever happens. The feedback cycle is seconds.
This is the skill you reach for after almost every meaningful code change. Think of it as an automated code reviewer that actually knows your project's conventions because it reads your CLAUDE.md.
What /batch Actually Does
/batch is a different animal entirely. It handles large-scale, parallelizable code migrations by:
- Interactively planning the migration with you first
- Spawning dozens of isolated agents to execute it in parallel
- Running each agent in its own git worktree (full isolation)
- Having each agent test its own work before opening a PR
Example usage: /batch migrate src/ from Solid to React
That single command kicks off a coordinated swarm. Each agent gets a slice of the codebase, works independently, validates its output, and surfaces a PR. You review a set of clean, tested PRs rather than doing the migration yourself file by file.
Before /batch: A migration from one framework to another, or renaming a pattern across hundreds of files, was a multi-day sprint. You'd either do it manually (risky, tedious), write a one-off script (time-consuming), or punt it to the next quarter.
After /batch: You describe the migration conversationally, Claude plans it with you, and then dozens of agents execute in parallel. The work that blocked a sprint becomes a morning task.
The Decision Rule
Use /simplify constantly -- after every code change as a quality gate before you commit. It's low-cost, fast, and catches things that accumulate into tech debt.
Use /batch when the scope is large and the pattern is clear. The key qualifier is "straightforward, parallelizable." A migration from one UI library to another qualifies. Refactoring your core business logic probably does not -- that kind of work requires context across the whole system that even parallel agents shouldn't be making calls on autonomously.
A useful test: could you write a clear spec for each file-level change without looking at every file individually? If yes, /batch can probably handle it. If the answer depends heavily on what's in each file, keep humans in the loop.
The Parallel Agent Pattern
Both skills represent the same underlying architectural shift: instead of one agent doing sequential work, multiple agents do parallel work with isolated state and explicit validation gates.
This is significant beyond the specific features. Cherny's description of /batch -- git worktrees for isolation, agents testing before PRing -- is a usable template for building your own parallel workflows. If your team uses Claude Code for custom tasks, the worktree-per-agent pattern is worth studying for anything where work can be split cleanly across units.
What This Means for AI Coding Workflows
The practical trajectory here is that more of the software lifecycle is moving from human-executed to agent-executed. Code review loops, migration work, compliance checking -- these are exactly the tasks that are tedious for humans but well-suited for agents with good isolation and test gates.
The teams that move fastest with this aren't going to be the ones who use these features as a crutch. They'll be the ones who understand what they're doing well enough to know when to trust the output and when to stay in the loop.
/simplify: trust it daily. /batch: use it deliberately.
Both skills are arriving in the next Claude Code update. If you're building workflows around Claude Code today and want help designing agent-based processes that fit your team's actual stack, Barista Labs works with small and mid-sized businesses on exactly that kind of integration.