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.

⭐2stars🔀0forks📁View on GitHub🕐Updated Jan 3, 2026⬇️2downloads

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.
namebatch-operations
descriptionUse 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:

  1. Complete all possible operations (don't abort on first failure)
  2. Report successes and failures separately using schema above
  3. For failed items: explain why, suggest fix
  4. Ask user: retry failed items, skip them, or abort remaining?

On total failure (0 successes):

  1. Stop after 2 consecutive failures
  2. Report common failure pattern
  3. Suggest checking: permissions, file existence, pattern validity
  4. 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
  • 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