batch-operations
Use when performing 3+ similar operations like file edits, searches, or git operations. Triggers on repetitive tasks, "do the same for", loop-like patterns. Enables parallel tool calls and batch-editor delegation.
When & Why to Use This Skill
The Batch Operations skill is designed to optimize developer workflows by automating repetitive tasks. It identifies patterns where three or more similar operations—such as file edits, searches, or Git commands—are required and executes them efficiently through parallel tool calls or delegation to specialized batch-editor agents. This skill significantly reduces latency and manual overhead in large-scale codebase refactoring and maintenance.
Use Cases
- Global Refactoring: Renaming variables, updating function signatures, or modifying import paths across multiple files simultaneously to ensure architectural consistency.
- Bulk Configuration Management: Reading, comparing, or updating settings across several environment-specific configuration files (e.g., dev, staging, prod) in a single operation.
- Automated Code Cleanup: Applying linting fixes, formatting changes, or license header updates across an entire directory or repository using chained bash commands.
- Parallel Data Inspection: Gathering information from multiple source files or logs at once to diagnose issues without sequential tool-call delays.
| name | batch-operations |
|---|---|
| description | Use when performing 3+ similar operations like file edits, searches, or git operations. Triggers on repetitive tasks, "do the same for", loop-like patterns. Enables parallel tool calls and batch-editor delegation. |
Batch Operations Skill
Persona: Efficiency obsessive - one operation is fine, three identical operations is a code smell.
Announce at start: "I'm using the batch-operations skill to process these efficiently."
Should NOT Attempt
- Batch operations that depend on previous results
- Batch across different file types without validation
- Use batch scripts on untested patterns
- Skip verification after batch changes
When to Batch
Use batching for 3+ similar operations: file edits, searches, test runs, git operations.
Batching Strategies
| Strategy | Example |
|---|---|
| Parallel Tool Calls | Read file1.py, file2.py, file3.py in same message |
| Chained Bash | for f in src/*.py; do sed -i 's/old/new/g' "$f"; done |
| Replace All | Edit with replace_all: true |
| batch-editor Agent | Task(subagent_type=batch-editor, prompt="Rename userId to user_id") |
Scripts
~/.claude/scripts/batch-process.sh items.txt "prompt"
~/.claude/scripts/batch-select.sh 'find . -name "*.py"' 'test' 10
~/.claude/scripts/batch-annotate.sh item1 item2 item3
Batch Indicators
- Third similar operation in a row
- "Now do the same for X"
- Loop in your head ("for each file...")
- Repetitive Edit tool calls
When NOT to Batch
- Each operation depends on previous result
- Files need different/custom changes
- User wants to review each change
- Operations need individual verification
- Error handling differs per item
- Changes span multiple interdependent systems
Examples
Example 1: Rename Variable Across Files
Task: Rename userId to user_id in 8 Python files
Approach: batch-editor agent
Task(subagent_type=batch-editor, prompt="Rename userId to user_id in src/models/*.py")
Example 2: Read Multiple Config Files
Task: Check settings in 4 config files Approach: Parallel tool calls
Read(file_path="config/dev.json")
Read(file_path="config/prod.json")
Read(file_path="config/test.json")
Read(file_path="config/local.json")
All in same message → parallel execution
Example 3: Update Import Statements
Task: Change from utils import X to from core.utils import X
Approach: Edit with replace_all
Edit(file_path="src/main.py", old_string="from utils import", new_string="from core.utils import", replace_all=true)
Repeat for each affected file
Response Schema (for batch results)
When reporting batch results, use this format:
Batch: [operation type] on [N] items
Succeeded (N):
- file1.py: [brief result]
- file2.py: [brief result]
Failed (N):
- file3.py: [error reason]
Summary: N/M succeeded
Failure Behavior
On partial batch failure:
- Complete all possible operations (don't abort on first failure)
- Report successes and failures separately using schema above
- For failed items: explain why, suggest fix
- Ask user: retry failed items, skip them, or abort remaining?
On total failure (0 successes):
- Stop after 2 consecutive failures
- Report common failure pattern
- Suggest checking: permissions, file existence, pattern validity
- Escalate to manual review
Escalation Triggers
Use Task(batch-editor) instead of manual batching when:
- 5+ files need same change
- Change requires understanding file context
- Pattern-based replacement might have false positives
Related Skills
- Use batch-editor agent for multi-file edits
- subagent-driven-development: Parallelize independent work
Integration
- batch-editor agent - For complex multi-file changes requiring context
- code-reviewer agent - Review batch changes before committing
- verification-before-completion skill - Verify all changes after batch