Script automation transforms Claude Code from an interactive assistant into a powerful automation engine. By combining hooks, custom commands, headless mode, and scripting patterns, you can automate everything from code formatting to large-scale migrations. This guide reveals how to build automation workflows that run autonomously while maintaining the flexibility to intervene when needed.
Hooks are Claude Code’s secret weapon for automation. They’re shell commands that execute automatically at specific points in Claude’s lifecycle, turning repetitive manual tasks into seamless background operations.
Hook Events
The hook system provides five strategic intervention points:
Let’s start with the most common automation: automatic code formatting.
Create the hooks configuration
mkdir -p .claudeAdd to .claude/settings.json
{ "hooks": [ { "matcher": "Edit|Write", "hooks": [ { "type": "command", "command": "prettier --write \"$CLAUDE_FILE_PATHS\"" } ] } ]}Test the hook
# Ask Claude to create a messy JavaScript fileclaude "Create a test.js file with unformatted code"# The file will be automatically formatted after creation!{ "hooks": [ { "matcher": "Edit", "hooks": [ { "type": "command", "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx prettier --write \"$CLAUDE_FILE_PATHS\"; elif [[ \"$CLAUDE_FILE_PATHS\" =~ \\.py$ ]]; then black \"$CLAUDE_FILE_PATHS\"; elif [[ \"$CLAUDE_FILE_PATHS\" =~ \\.go$ ]]; then gofmt -w \"$CLAUDE_FILE_PATHS\"; fi" } ] } ]}{ "hooks": [ { "matcher": "Edit", "hooks": [ { "type": "command", "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit --skipLibCheck \"$CLAUDE_FILE_PATHS\" || echo '⚠️ TypeScript errors detected - please review'; fi" } ] } ]}{ "hooks": [ { "matcher": "Write|Edit", "hooks": [ { "type": "command", "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(js|ts|py)$ ]]; then semgrep --config=auto \"$CLAUDE_FILE_PATHS\" || echo 'Security scan complete'; fi" } ] } ]}Hooks receive rich context through environment variables:
# Available in all hooks$CLAUDE_FILE_PATHS # Space-separated list of affected files$CLAUDE_SESSION_ID # Unique session identifier$CLAUDE_TOOL_NAME # Name of the tool being executed$CLAUDE_USER_PROMPT # The original user prompt
# JSON payload via stdin{ "hookEventName": "PostToolUse", "sessionId": "uuid-here", "toolName": "Edit", "filePaths": ["src/index.ts"], "result": "success"}Custom slash commands turn complex automation workflows into simple, parameterized commands. They’re stored as Markdown files and can be shared across your team.
Create the commands directory
mkdir -p .claude/commandsCreate your first command (.claude/commands/test.md)
Please create comprehensive tests for: $ARGUMENTS
Test requirements:- Use our standard testing framework- Include unit and integration tests- Mock external dependencies- Test error cases and edge conditions- Achieve at least 80% coverage- Place tests in __tests__ directory- Follow our naming convention: *.test.tsUse the command
claude> /test UserService# Claude generates comprehensive tests for UserServiceMigration Command
Migrate $ARGUMENTS from our old API to the new API:
1. Find all usages of the old API2. Update imports to use new package3. Transform method calls to new syntax4. Update any type definitions5. Run tests to verify migration6. Create a migration reportSecurity Audit
Perform security audit on: $ARGUMENTS
- Check for SQL injection vulnerabilities- Scan for XSS possibilities- Review authentication flows- Check for exposed secrets- Verify input validation- Generate security reportPerformance Analysis
Analyze performance of: $ARGUMENTS
- Profile the code execution- Identify bottlenecks- Check for N+1 queries- Review algorithm complexity- Suggest optimizations- Create benchmark testsDocumentation Generator
Generate documentation for: $ARGUMENTS
- Create comprehensive docstrings- Generate API documentation- Include usage examples- Document edge cases- Create markdown guides- Update README if neededFor larger teams, organize commands hierarchically:
.claude/commands/├── backend/│ ├── migrate.md # /backend:migrate│ ├── optimize.md # /backend:optimize│ └── test.md # /backend:test├── frontend/│ ├── component.md # /frontend:component│ ├── style.md # /frontend:style│ └── test.md # /frontend:test└── devops/ ├── deploy.md # /devops:deploy └── monitor.md # /devops:monitorHeadless mode enables Claude Code to run in non-interactive environments, perfect for CI/CD automation.
# Run a single commandclaude -p "Fix all linting errors" --output-format stream-json
# With specific tools allowedclaude -p "Update dependencies" --allowedTools "Edit Bash(npm:*)"
# Verbose mode for debuggingclaude -p "Run security audit" --verbosename: AI Code Reviewon: [pull_request]
jobs: review: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4
- name: Install Claude Code run: npm install -g @anthropic-ai/claude-code
- name: Run AI Review run: | claude -p "Review the changes in this PR for: - Code quality issues - Security vulnerabilities - Performance problems - Suggest improvements Output as markdown" \ --output-format stream-json > review.json
- name: Post Review Comment uses: actions/github-script@v7 with: script: | const review = require('./review.json'); github.rest.issues.createComment({ issue_number: context.issue.number, owner: context.repo.owner, repo: context.repo.repo, body: review.content });#!/bin/bash# Run Claude Code to check staged filesstaged_files=$(git diff --cached --name-only)
if [ ! -z "$staged_files" ]; then claude -p "Check these files for issues: $staged_files - Look for console.log statements - Check for commented out code - Verify no secrets are exposed Report any issues found" \ --allowedTools "Read" \ --output-format stream-json | jq -r '.content'
# Exit with error if issues found if [ $? -ne 0 ]; then echo "Pre-commit check failed. Please fix issues before committing." exit 1 fifiFanning Out Pattern
Use this pattern for processing many files independently:
#!/bin/bash# Generate task listfind src/components -name "*.jsx" > components.txt
# Process each componentwhile read -r file; do echo "Migrating $file..." claude -p "Convert $file from class component to functional component with hooks. Return 'OK' if successful, 'FAIL' if not possible." \ --allowedTools "Edit Read" \ --output-format stream-json | jq -r '.status'done < components.txtPipeline Pattern
Chain Claude Code with other tools:
# Analyze logs and send alertstail -f /var/log/app.log | \claude -p "Monitor this log stream. If you see any errors or anomalies, output a JSON object with severity and message" \ --output-format stream-json | \jq -c 'select(.severity == "high")' | \while read alert; do # Send to alerting system curl -X POST https://alerts.example.com/webhook \ -H "Content-Type: application/json" \ -d "$alert"doneRun multiple Claude instances for massive parallelization:
#!/bin/bash# Create work directoriesfor i in {1..4}; do git worktree add "../refactor-$i" "refactor-branch-$i"done
# Launch parallel Claude instancestmux new-session -d -s refactor-1 'cd ../refactor-1 && claude -p "Refactor authentication module"'tmux new-session -d -s refactor-2 'cd ../refactor-2 && claude -p "Refactor user management"'tmux new-session -d -s refactor-3 'cd ../refactor-3 && claude -p "Refactor payment processing"'tmux new-session -d -s refactor-4 'cd ../refactor-4 && claude -p "Refactor notification system"'
# Monitor progresswatch -n 5 'tmux list-sessions'Automate changes across multiple services:
#!/bin/bashservices=("user-service" "order-service" "payment-service" "notification-service")new_version="v2.0"
for service in "${services[@]}"; do echo "Updating $service to API $new_version..."
cd "../$service" || continue
claude -p "Update this service to use API $new_version: 1. Update client library to $new_version 2. Modify all API calls to use new endpoints 3. Update request/response types 4. Run tests to verify 5. Commit with message: 'chore: update to API $new_version' " --allowedTools all --dangerously-skip-permissions
# Push changes git push origin "api-update-$new_version"done
# Create PR for all servicesgh pr create --title "Update all services to API $new_version" \ --body "Automated update of all services to use API $new_version"Automate security and compliance checks:
{ "hooks": [ { "matcher": "UserPromptSubmit", "hooks": [ { "type": "command", "command": "./scripts/compliance-check.sh \"$CLAUDE_USER_PROMPT\"" } ] }, { "matcher": "Write|Edit", "hooks": [ { "type": "command", "command": "./scripts/security-scan.sh \"$CLAUDE_FILE_PATHS\"" } ] } ]}Automatically maintain documentation:
Prepare release $ARGUMENTS:
1. Generate changelog from git commits2. Update version numbers in all files3. Generate API documentation4. Update SDK documentation5. Create migration guide if needed6. Generate release notes7. Create git tag8. Build and test release artifacts
Use our standard templates and follow semantic versioning.Track Claude Code usage for insights:
#!/bin/bash# Log all tool usageecho "{ \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"session_id\": \"$CLAUDE_SESSION_ID\", \"tool\": \"$CLAUDE_TOOL_NAME\", \"files\": \"$CLAUDE_FILE_PATHS\", \"user\": \"$(whoami)\", \"project\": \"$(basename $(pwd))\"}" >> ~/.claude/usage.jsonl
# Send to monitoring systemif [ "$CLAUDE_TOOL_NAME" = "Stop" ]; then # Session ended, send metrics curl -X POST https://metrics.example.com/claude-usage \ -H "Content-Type: application/json" \ -d @~/.claude/usage.jsonl
# Clear log > ~/.claude/usage.jsonlfiAutomation Guidelines
DO:
DON’T:
When building automation workflows, consider:
Script automation in Claude Code transforms repetitive tasks into background magic. By mastering hooks, custom commands, headless mode, and automation patterns, you create workflows that handle the mundane while you focus on the creative. Start with simple formatting hooks, gradually build your command library, and soon you’ll have an automation suite that makes your entire team more productive. The key is finding the right balance – automate the repetitive, but maintain human oversight for the critical.