Script Automation

You have a Claude Code workflow that works every time: pipe in the git diff, ask for a changelog entry, format it, append to CHANGELOG.md. You run it before every release. But it takes five manual steps and you forget the exact prompt every time. Scripting turns this from a manual workflow into a single command.

What You Will Walk Away With

• Print mode patterns for scripting Claude Code into pipelines
• Pre-commit hooks that run Claude Code before every commit
• Cron jobs for scheduled codebase maintenance
• Error handling and retry patterns for production scripts

Print Mode Fundamentals

The -p flag makes Claude Code scriptable. It takes a prompt, processes it, prints the result, and exits:

# Basic usage
claude -p "What does this project do?"

# With piped input
cat error.log | claude -p "What caused this error?"

# With output format
claude -p "List all TODO comments in the codebase" --output-format json

# With budget limits
claude -p "Refactor src/utils.ts" --max-turns 5 --max-budget-usd 1.00

Output Formats

Format	Use Case	Example
text (default)	Human-readable output	--output-format text
json	Script consumption	--output-format json
stream-json	Real-time streaming	--output-format stream-json

Tip

Copy-paste changelog generator script:

#!/bin/bash
# changelog.sh -- Generate changelog entry from recent commits
VERSION="${1:-unreleased}"

git log --oneline "$(git describe --tags --abbrev=0 2>/dev/null || echo HEAD~20)..HEAD" | \
  claude -p "Generate a changelog entry for version $VERSION from these commits. \
    Format: ## [$VERSION] - $(date +%Y-%m-%d) \
    Group by: Added, Changed, Fixed, Removed. \
    Use past tense. One line per change." \
  --output-format text

Pre-Commit Hooks

Run Claude Code as a pre-commit check. This catches issues before code reaches the repository:

Basic Pre-Commit Review

.git/hooks/pre-commit

#!/bin/bash
# Quick review of staged changes

STAGED_DIFF=$(git diff --cached --no-color)

if [ -z "$STAGED_DIFF" ]; then
  exit 0
fi

RESULT=$(echo "$STAGED_DIFF" | claude -p "Review this diff for critical issues only: \
  security vulnerabilities, obvious bugs, and broken error handling. \
  If you find CRITICAL issues, output 'BLOCK: [reason]'. \
  If the code looks safe, output 'PASS'." \
  --max-turns 3 --output-format text 2>&1)

if echo "$RESULT" | grep -q "BLOCK:"; then
  echo "Pre-commit review found issues:"
  echo "$RESULT"
  exit 1
fi

exit 0

Tip

Copy-paste pre-commit hook for secret detection:

#!/bin/bash
# .git/hooks/pre-commit -- Block commits containing secrets

STAGED_DIFF=$(git diff --cached --no-color)

echo "$STAGED_DIFF" | claude -p "Check if this diff contains any secrets, API keys, \
  tokens, passwords, or credentials. Check for patterns like: \
  - API keys (sk_, pk_, api_key, apiKey) \
  - Passwords or tokens in string literals \
  - AWS/GCP/Azure credentials \
  - Private keys or certificates \
  Output 'CLEAN' if no secrets found. Output 'SECRET: [location]' for each finding." \
  --max-turns 2 --output-format text | while IFS= read -r line; do
    if echo "$line" | grep -q "SECRET:"; then
      echo "BLOCKED: Possible secret detected in commit"
      echo "$line"
      exit 1
    fi
  done

Cron Jobs

Daily Code Health Check

#!/bin/bash
# cron-health-check.sh -- Run daily at 6 AM
# Crontab: 0 6 * * * /path/to/cron-health-check.sh

cd /path/to/project

REPORT=$(claude -p "Run a health check on this project: \
  1. Check for TypeScript errors: npx tsc --noEmit \
  2. Run the linter: npm run lint \
  3. Check for outdated dependencies: npm outdated \
  4. Summarize findings in a brief report" \
  --max-turns 10 \
  --dangerously-skip-permissions \
  --output-format text 2>&1)

# Send via notification (adjust for your team's channel)
echo "$REPORT" | mail -s "Daily Code Health: $(date +%Y-%m-%d)" team@company.com

Weekly Dependency Audit

weekly-audit.sh

#!/bin/bash
cd /path/to/project

claude -p "Run npm audit and analyze the results. \
  For each vulnerability: \
  1. Assess if it affects us (check if the vulnerable code path is used) \
  2. Check if an upgrade is available \
  3. Note any breaking changes in the upgrade \
  Output a prioritized action list." \
  --max-turns 8 \
  --dangerously-skip-permissions \
  --output-format text > /tmp/audit-report.txt

# Only notify if there are actionable findings
if grep -q "CRITICAL\|HIGH" /tmp/audit-report.txt; then
  cat /tmp/audit-report.txt  # Send to your notification system
fi

Error Handling and Retry Patterns

Robust Script Template

#!/bin/bash
set -euo pipefail

MAX_RETRIES=3
RETRY_DELAY=5

run_claude() {
  local prompt="$1"
  local retries=0

  while [ $retries -lt $MAX_RETRIES ]; do
    result=$(claude -p "$prompt" --max-turns 5 --output-format text 2>&1)
    exit_code=$?

    if [ $exit_code -eq 0 ]; then
      echo "$result"
      return 0
    fi

    retries=$((retries + 1))
    echo "Attempt $retries failed. Retrying in ${RETRY_DELAY}s..." >&2
    sleep $RETRY_DELAY
  done

  echo "Failed after $MAX_RETRIES attempts" >&2
  return 1
}

# Usage
run_claude "Analyze the test coverage report and identify untested code paths"

Tip

Copy-paste production-ready script template:

#!/bin/bash
set -euo pipefail

# Configuration
PROJECT_DIR="/path/to/project"
MAX_BUDGET="2.00"
MAX_TURNS="10"
LOG_FILE="/tmp/claude-automation-$(date +%Y%m%d).log"

# Logging
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"; }

cd "$PROJECT_DIR"

log "Starting automation run"

RESULT=$(claude -p "Your prompt here" \
  --max-turns "$MAX_TURNS" \
  --max-budget-usd "$MAX_BUDGET" \
  --output-format json 2>&1) || {
  log "ERROR: Claude Code failed with exit code $?"
  exit 1
}

log "Completed successfully"
echo "$RESULT"

When This Breaks

Script hangs waiting for permissions: In print mode, Claude Code stops when it needs permission for a dangerous operation. Use --dangerously-skip-permissions for trusted environments, or --allowedTools to pre-approve specific operations.

Output format inconsistency: Claude Code’s text output may vary between runs. When parsing output programmatically, use --output-format json and parse with jq. Do not rely on specific text formatting.

Budget exceeded mid-task: The --max-budget-usd flag stops execution when the budget is reached. For critical tasks, set a generous budget and monitor costs via /cost or OpenTelemetry.

Cron job environment differs from shell: Cron jobs run with a minimal environment. Ensure your PATH includes node and claude, and that all required environment variables (API keys, proxy settings) are set in the crontab.

What is Next

• Batch Operations — Combine scripting with batch patterns for large-scale automation
• GitHub Actions — Take your scripts to CI/CD
• Hooks and Automation — Trigger scripts automatically via hooks