Automatyzacja zadań

Automatyzacja to miejsce, gdzie Claude Code przekształca się z pomocnego asystenta w multiplikator siły. Ta lekcja pokazuje, jak tworzyć samoobsługowe przepływy pracy, automatyzować powtarzalne zadania i budować inteligentne pipeline’y, które obsługują złożone operacje przy minimalnej interwencji człowieka.

Moc zautomatyzowanego developmentu

Scenariusz: Twój zespół utrzymuje 50 mikrousług. Aktualizacja bezpieczeństwa wymaga zmiany middleware autentykacji we wszystkich usługach, aktualizacji testów i tworzenia pull requestów. Robienie tego ręcznie zajęłoby dni. Z automatyzacją Claude Code to jedno popołudnie.

Możliwości automatyzacji Claude Code wykraczają daleko poza proste skrypty. Może organizować złożone, wieloetapowe operacje w całej bazie kodu, obsługiwać logikę warunkową, a nawet samodzielnie korygować błędy.

Hooki: automatyzacja zachowania Claude’a

Hooki są fundamentem automatyzacji Claude Code. To polecenia powłoki, które wykonują się automatycznie w określonych punktach cyklu życia Claude’a, przekształcając sugestie w wymuszane wzorce.

Zrozumienie zdarzeń hooków

Claude Code udostępnia kilka punktów zaczepienia:

PreToolUse

Uruchamia się przed wykonaniem jakiegokolwiek narzędzia przez Claude’a. Idealne do walidacji, kontroli bezpieczeństwa lub przygotowania środowiska.

PostToolUse

Wykonuje się po pomyślnym zakończeniu narzędzia. Idealne do formatowania, testowania lub operacji czyszczenia.

Notification

Wyzwala się, gdy Claude potrzebuje twojej uwagi. Dostosuj alerty dla różnych platform lub poziomów pilności.

Stop

Uruchamia się, gdy Claude kończy odpowiadanie. Świetne do końcowych kontroli, podsumowań lub wyzwalania kolejnych akcji.

Implementacja pierwszego hooka

Stwórzmy hook, który automatycznie formatuje kod po każdej edycji:

1. Utwórz konfigurację hooków

   .claude/settings.json

   {
     "hooks": [
       {
         "matcher": "Edit|Write",
         "hooks": [
           {
             "type": "command",
             "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
           }
         ]
       }
     ]
   }

2. Dodaj formatowanie specyficzne dla języka

   {
     "matcher": "Edit",
     "hooks": [
       {
         "type": "command",
         "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.py$ ]]; then black \"$CLAUDE_FILE_PATHS\"; fi"
       },
       {
         "type": "command",
         "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.go$ ]]; then gofmt -w \"$CLAUDE_FILE_PATHS\"; fi"
       }
     ]
   }

3. Przetestuj hook

   > Utwórz nową funkcję Python do obliczania liczb Fibonacciego
   # Claude tworzy plik, następnie Black automatycznie go formatuje

Zaawansowane wzorce hooków

Hooki walidacyjne: Zapobiegaj niebezpiecznym operacjom

{
  "matcher": "Edit",
  "hooks": [
    {
      "type": "command",
      "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ production|secret ]]; then echo 'BLOKADA: Nie można edytować wrażliwych plików' && exit 1; fi"
    }
  ]
}

Hooki testowe: Uruchamiaj testy po zmianach

{
  "matcher": "Edit",
  "hooks": [
    {
      "type": "command",
      "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.spec\\.|test\\. ]]; then npm test -- \"$CLAUDE_FILE_PATHS\"; fi"
    }
  ]
}

Hooki compliance: Wymuszanie standardów

{
  "matcher": "Edit",
  "hooks": [
    {
      "type": "command",
      "command": "/path/to/security-scanner.sh \"$CLAUDE_FILE_PATHS\" || (echo 'Kontrola bezpieczeństwa nieudana' && exit 1)"
    }
  ]
}

Tryb headless: automatyzacja na skalę

Tryb headless (claude -p) umożliwia programowe użycie Claude Code w skryptach, pipeline’ach CI/CD i zautomatyzowanych przepływach pracy.

Podstawowe operacje headless

# Proste jednorazowe zadanie
claude -p "Zaktualizuj wszystkie nagłówki praw autorskich na 2025"

# Z określonymi dozwolonymi narzędziami
claude -p "Napraw wszystkie błędy ESLint" --allowedTools Edit,Bash

# Wyjście JSON do parsowania
claude -p "Wylistuj wszystkie komentarze TODO" --output-format json

Budowanie skryptów automatyzacji

Wzorzec przetwarzania wsadowego: Obsługa wielu plików lub zadań

migrate-components.sh

#!/bin/bash
# Wygeneruj listę komponentów do migracji
claude -p "Wylistuj wszystkie komponenty klasowe wymagające konwersji na hooki" \
  --output-format json > components.json

# Przetwórz każdy komponent
while read -r file; do
  claude -p "Konwertuj $file na użycie React hooks" \
    --allowedTools Edit \
    --max-turns 10
done < <(jq -r '.files[]' components.json)

# Zweryfikuj migracje
claude -p "Uruchom testy dla wszystkich zmigrowanych komponentów"

Integracja pipeline: Przekazuj wynik Claude’a do innych narzędzi

# Wygeneruj dokumentację API i przekaż do generatora strony statycznej
claude -p "Wygeneruj specyfikację OpenAPI z naszych tras FastAPI" --json | \
  npx swagger-to-markdown | \
  hugo new content/api/reference.md

Zaawansowane wzorce headless

Wzorzec Fan-Out

# Przetwarzaj wiele zadań równolegle
TASKS=(
  "service-auth:Zaktualizuj autentykację na JWT"
  "service-user:Dodaj rate limiting do endpointów API"
  "service-payment:Zaimplementuj logikę ponawiania webhook"
)

for task in "${TASKS[@]}"; do
  IFS=':' read -r service description <<< "$task"
  (
    cd "../$service"
    claude -p "$description" \
      --allowedTools Edit,Write,Bash \
      --max-retries 3
  ) &
done

wait # Czekaj na wszystkie zadania równoległe

Automatyzacja warunkowa

# Kontynuuj tylko jeśli warunki są spełnione
if claude -p "Czy są jakieś nieprzechodzące testy?" --json | jq -e '.failing_tests > 0'; then
  claude -p "Napraw nieprzechodzące testy" --allowedTools Edit,Bash

  if claude -p "Czy testy przechodzą teraz?" --json | jq -e '.all_passing'; then
    git add -A
    git commit -m "fix: rozwiązane nieprzechodzące testy (automatycznie)"
  fi
fi

Niestandardowe slash commands dla automatyzacji

Twórz wzorce automatyzacji wielokrotnego użytku z niestandardowymi slash commands:

Tworzenie poleceń automatyzacji

.claude/commands/migrate-database.md

Migruj schemat bazy danych z wersji $ARGUMENTS. Wykonaj te kroki:

1. Utwórz nowy plik migracji z timestamp
2. Przeanalizuj różnice między bieżącym a docelowym schematem
3. Wygeneruj SQL migracji do przodu
4. Wygeneruj SQL rollback
5. Utwórz test migracji
6. Zaktualizuj dokumentację migracji

Upewnij się:
- Kompatybilność z wdrożeniem zero downtime
- Zachowanie integralności danych
- Optymalizacja wydajności dla dużych tabel

Użycie: /migrate-database v2.3.0

Biblioteka automatyzacji zespołu

Zbuduj bibliotekę poleceń automatyzacji:

.claude/commands/
├── security/
│   ├── audit.md           # Workflow audytu bezpieczeństwa
│   ├── update-deps.md     # Aktualizacje zależności
│   └── rotate-keys.md     # Proces rotacji kluczy
├── deployment/
│   ├── release.md         # Automatyzacja wydań
│   ├── rollback.md        # Procedury rollback
│   └── hotfix.md          # Workflow nagłych poprawek
└── maintenance/
    ├── cleanup.md         # Zadania czyszczenia kodu
    ├── optimize.md        # Optymalizacja wydajności
    └── refactor.md        # Wzorce refaktoryzacji

Integracja CI/CD

Integracja GitHub Actions

Automatyczne przeglądy PR

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Przejrzyj ten PR pod kątem:
            - Luk bezpieczeństwa
            - Problemów wydajności
            - Brakujących przypadków brzegowych
            - Problemów jakości kodu

            Komentuj tylko znaczące problemy.

Automatyczne rozwiązywanie problemów

name: Auto-fix Issues
on:
  issues:
    types: [labeled]

jobs:
  auto-fix:
    if: github.event.label.name == 'auto-fix'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Create fix branch
        run: |
          git checkout -b fix/issue-${{ github.event.issue.number }}

      - name: Claude fix
        run: |
          claude -p "Napraw problem: ${{ github.event.issue.title }}

          Opis: ${{ github.event.issue.body }}

          Utwórz kompletną poprawkę z testami" \
          --allowedTools Edit,Write,Bash \
          --dangerously-skip-permissions

      - name: Create PR
        uses: peter-evans/create-pull-request@v5
        with:
          title: "fix: ${{ github.event.issue.title }}"
          body: "Naprawia #${{ github.event.issue.number }}"

Automatyzacja wielu instancji

Wykorzystaj wiele instancji Claude’a do złożonych przepływów pracy:

Przetwarzanie równoległe

#!/bin/bash
# System równoległego przeglądu kodu

review_branch() {
  local branch=$1
  local reviewer_focus=$2

  git worktree add "../review-$branch" "$branch"
  cd "../review-$branch"

  claude -p "Przejrzyj tę gałąź skupiając się na: $reviewer_focus
    Dostarcz szczegółową opinię i sugestie" \
    --output-format json > "review-$reviewer_focus.json"
}

# Uruchom specjalistyczne przeglądy równolegle
review_branch "feature/auth" "bezpieczeństwo" &
review_branch "feature/auth" "wydajność" &
review_branch "feature/auth" "pokrycie testami" &

wait

# Agreguj przeglądy
claude -p "Podsumuj te przeglądy kodu i utwórz ujednolicony raport" \
  --attach review-*.json

Architektura pipeline

graph LR A[Kod źródłowy] --> B[Claude Analyzer] B --> C{Znalezione problemy?} C -->|Tak| D[Claude Fixer] C -->|Nie| E[Claude Optimizer] D --> F[Claude Tester] E --> F F --> G[Claude Documenter] G --> H[Gotowe do wdrożenia]

Scenariusze automatyzacji z prawdziwego świata

Scenariusz 1: Automatyzacja aktualizacji zależności

1. Skonfiguruj skrypt automatyzacji

   update-dependencies.sh

   #!/bin/bash
   # Sprawdź przestarzałe zależności
   OUTDATED=$(npm outdated --json)
   
   if [ -n "$OUTDATED" ]; then
     # Utwórz gałąź aktualizacji
     git checkout -b chore/dependency-updates-$(date +%Y%m%d)
   
     # Aktualizuj zależności inteligentnie
     claude -p "Zaktualizuj zależności NPM na podstawie tej listy przestarzałych:
     $OUTDATED
   
     Dla każdej aktualizacji:
     1. Sprawdź breaking changes
     2. Zaktualizuj kod jeśli potrzeba
     3. Uruchom testy
     4. Zaktualizuj dokumentację" \
     --allowedTools Edit,Bash
   
     # Jeśli sukces, utwórz PR
     if npm test; then
       gh pr create --title "chore: aktualizacja zależności" \
         --body "Automatyczne aktualizacje zależności z niezbędnymi zmianami w kodzie"
     fi
   fi

2. Zaplanuj przez cron lub CI

   .github/workflows/update-deps.yml

   on:
     schedule:
       - cron: '0 0 * * 1' # Tygodniowo w poniedziałek

Scenariusz 2: Refaktoryzacja na dużą skalę

# Refaktoryzacja autentykacji w 100+ plikach
claude -p "Utwórz plan refaktoryzacji migracji z cookies na tokeny JWT" \
  --output-format json > refactor-plan.json

# Wykonaj plan ze śledzeniem postępu
total=$(jq '.steps | length' refactor-plan.json)
current=0

jq -r '.steps[] | @json' refactor-plan.json | while read -r step; do
  current=$((current + 1))
  echo "[$current/$total] Przetwarzanie..."

  task=$(echo "$step" | jq -r '.task')
  files=$(echo "$step" | jq -r '.files[]')

  claude -p "$task" \
    --attach $files \
    --allowedTools Edit,Write \
    --max-turns 20

  # Checkpoint po każdym głównym kroku
  git add -A
  git commit -m "refactor: $task (krok $current/$total)"
done

Najlepsze praktyki automatyzacji

Wytyczne automatyzacji

1. Zawsze uwzględniaj mechanizmy rollback - Automatyzacja powinna być odwracalna
2. Używaj trybów dry-run - Testuj automatyzację przed zastosowaniem zmian
3. Implementuj stopniowe wdrażanie - Zacznij od podzbioru przed pełną automatyzacją
4. Monitoruj i loguj wszystko - Śledź co robi automatyzacja
5. Ustaw odpowiednie timeouty - Zapobiegaj procesom uciekającym spod kontroli

Obsługa błędów w automatyzacji

# Solidna automatyzacja z obsługą błędów
run_with_retry() {
  local max_attempts=3
  local attempt=1

  while [ $attempt -le $max_attempts ]; do
    if "$@"; then
      return 0
    fi

    echo "Próba $attempt nieudana. Ponawiam..."
    attempt=$((attempt + 1))
    sleep 5
  done

  return 1
}

# Użyj z Claude
run_with_retry claude -p "Złożone zadanie refaktoryzacji" --max-turns 30

Metryki automatyzacji

Śledź efektywność swojej automatyzacji:

# Śledź metryki automatyzacji
claude -p "Przeanalizuj naszą historię git i oblicz:
- Czas zaoszczędzony przez automatyczne commity
- Wskaźnik błędów w zmianach automatycznych vs ręcznych
- Poprawa pokrycia testami przez automatyczne generowanie testów
- Wyniki kompletności dokumentacji

Wynik jako raport markdown" > automation-metrics.md

Następne kroki

Automatyzacja z Claude Code to podróż od prostych skryptów do wyrafinowanych przepływów pracy. Zacznij od podstawowych hooków, eksperymentuj z trybem headless dla powtarzalnych zadań, następnie stopniowo buduj bardziej złożone wzorce automatyzacji.

Kluczem jest identyfikacja powtarzalnych, podatnych na błędy zadań w twoim przepływie pracy i systematyczna ich automatyzacja. Każda automatyzacja, którą tworzysz, staje się klockiem konstrukcyjnym dla bardziej złożonych przepływów pracy.

Gotowy do obsługi transformacji kodu na dużą skalę? Przejdź do Refaktoryzacja, aby nauczyć się, jak Claude Code może pomóc bezpiecznie restrukturyzować całe bazy kodu.